commit d0aab9212a062f5a87b98e2e851304f84a93f381 Author: wehub-resource-sync Date: Mon Jul 13 12:07:39 2026 +0800 chore: import upstream snapshot with attribution diff --git a/.flake8 b/.flake8 new file mode 100644 index 0000000..c3aed79 --- /dev/null +++ b/.flake8 @@ -0,0 +1,7 @@ +[flake8] +ignore = E203, E266, E501, E701, E704, W503, B907 +# line length is intentionally set to 80 here because black uses Bugbear +# See https://black.readthedocs.io/en/stable/guides/using_black_with_other_tools.html#bugbear for more details +max-line-length = 80 +max-complexity = 18 +select = B,E,F,W,T4,B9 diff --git a/.git_archival.txt b/.git_archival.txt new file mode 100644 index 0000000..be59c4c --- /dev/null +++ b/.git_archival.txt @@ -0,0 +1,3 @@ +node: $Format:%H$ +node-date: $Format:%cI$ +describe-name: $Format:%(describe:tags=true,match=[0-9]*)$ diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..dcda633 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,2 @@ +.git_archival.txt export-subst +*.py diff=python diff --git a/.github/CODE_OF_CONDUCT.md b/.github/CODE_OF_CONDUCT.md new file mode 100644 index 0000000..dbd5f23 --- /dev/null +++ b/.github/CODE_OF_CONDUCT.md @@ -0,0 +1,11 @@ +# Treat each other well + +Everyone participating in the _Black_ project, and in particular in the issue tracker, +pull requests, and social media activity, is expected to treat other people with respect +and more generally to follow the guidelines articulated in the +[Python Community Code of Conduct](https://www.python.org/psf/codeofconduct/). + +At the same time, humor is encouraged. In fact, basic familiarity with Monty Python's +Flying Circus is expected. We are not savages. + +And if you _really_ need to slap somebody, do it with a fish while dancing. diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md new file mode 100644 index 0000000..3d2406a --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report.md @@ -0,0 +1,64 @@ +--- +name: Bug report +about: Create a report to help us improve Black's quality +title: "" +labels: "T: bug" +assignees: "" +--- + + + +**Describe the bug** + + + +**To Reproduce** + + + +For example, take this code: + +```python +this = "code" +``` + +And run it with these arguments: + +```sh +$ black file.py --target-version py310 +``` + +The resulting error is: + +> cannot format file.py: INTERNAL ERROR: ... + +**Expected behavior** + + + +**Environment** + + + +- Black's version: +- OS and Python version: + +**Additional context** + + diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml new file mode 100644 index 0000000..f4703ff --- /dev/null +++ b/.github/ISSUE_TEMPLATE/config.yml @@ -0,0 +1,11 @@ +# See also: https://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/configuring-issue-templates-for-your-repository#configuring-the-template-chooser + +# This is the default and blank issues are useful so let's keep 'em. +blank_issues_enabled: true + +contact_links: + - name: Chat on Python Discord + url: https://discord.gg/RtVdv86PrH + about: >- + User support, questions, and other lightweight requests can be handled via the + #black-formatter text channel we have on Python Discord. diff --git a/.github/ISSUE_TEMPLATE/docs-issue.md b/.github/ISSUE_TEMPLATE/docs-issue.md new file mode 100644 index 0000000..d362b86 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/docs-issue.md @@ -0,0 +1,27 @@ +--- +name: Documentation +about: Report a problem with or suggest something for the documentation +title: "" +labels: "T: documentation" +assignees: "" +--- + +**Is this related to a problem? Please describe.** + + + +**Describe the solution you'd like** + + + +**Describe alternatives you've considered** + + + +**Additional context** + + diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md new file mode 100644 index 0000000..a34e4a0 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature_request.md @@ -0,0 +1,27 @@ +--- +name: Feature request +about: Suggest an idea for this project +title: "" +labels: "T: enhancement" +assignees: "" +--- + +**Is your feature request related to a problem? Please describe.** + + + +**Describe the solution you'd like** + + + +**Describe alternatives you've considered** + + + +**Additional context** + + diff --git a/.github/ISSUE_TEMPLATE/style_issue.md b/.github/ISSUE_TEMPLATE/style_issue.md new file mode 100644 index 0000000..ff9283f --- /dev/null +++ b/.github/ISSUE_TEMPLATE/style_issue.md @@ -0,0 +1,38 @@ +--- +name: Code style issue +about: Help us improve the Black code style +title: "" +labels: "T: style" +assignees: "" +--- + +**Describe the style change** + + + +**Examples in the current _Black_ style** + + + +```python +def f(): + """This code should be formatted as per the current Black style""" + pass +``` + +**Desired style** + + + +```python +def f( + ): + """This code can be formatted however you suggest!""" + pass +``` + +**Additional context** + + diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md new file mode 100644 index 0000000..9675ea5 --- /dev/null +++ b/.github/PULL_REQUEST_TEMPLATE.md @@ -0,0 +1,42 @@ + + +### Description + + + +### Checklist - did you ... + + + +- [ ] Implement any code style changes under the `--preview` style, following the stability policy? +- [ ] Add an entry in `CHANGES.md` if necessary? +- [ ] Add / update tests if necessary? +- [ ] Add new / update outdated documentation? + + diff --git a/.github/dependabot.yml b/.github/dependabot.yml new file mode 100644 index 0000000..482d659 --- /dev/null +++ b/.github/dependabot.yml @@ -0,0 +1,21 @@ +# https://docs.github.com/en/code-security/supply-chain-security/keeping-your-dependencies-updated-automatically/configuration-options-for-dependency-updates + +version: 2 + +updates: + - package-ecosystem: "github-actions" + # Workflow files in .github/workflows will be checked + directory: "/" + labels: ["ci: skip news", "C: dependencies", "C: maintenance"] + schedule: + interval: daily + cooldown: + default-days: 7 + + - package-ecosystem: "pip" + directory: "/" + labels: ["ci: skip news", "C: dependencies"] + schedule: + interval: daily + cooldown: + default-days: 7 diff --git a/.github/workflows/changelog.yml b/.github/workflows/changelog.yml new file mode 100644 index 0000000..ab98b49 --- /dev/null +++ b/.github/workflows/changelog.yml @@ -0,0 +1,25 @@ +name: changelog + +on: + pull_request: + types: [opened, synchronize, labeled, unlabeled, reopened] + +permissions: + contents: read + +jobs: + check: + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + with: + persist-credentials: false + + - name: Grep CHANGES.md for PR number + if: > + contains(github.event.pull_request.labels.*.name, 'ci: skip news') != true + run: | + grep -Pz "\((\n\s*)?#${{ github.event.pull_request.number }}(\n\s*)?\)" CHANGES.md || \ + (echo "Please add '(#${{ github.event.pull_request.number }})' change line to CHANGES.md (or if appropriate, ask a maintainer to add the 'ci: skip news' label)" && \ + exit 1) diff --git a/.github/workflows/diff_shades.yml b/.github/workflows/diff_shades.yml new file mode 100644 index 0000000..2c22f31 --- /dev/null +++ b/.github/workflows/diff_shades.yml @@ -0,0 +1,240 @@ +name: diff-shades + +on: + push: + branches: [main] + paths: + - src/** + - pyproject.toml + - scripts/diff_shades_gha_helper.py + - .github/workflows/diff_shades.yml + - .github/workflows/diff_shades_comment.yml + + pull_request: + paths: + - src/** + - pyproject.toml + - scripts/diff_shades_gha_helper.py + - .github/workflows/diff_shades.yml + - .github/workflows/diff_shades_comment.yml + +concurrency: + group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.run_id }} + cancel-in-progress: true + +env: + HATCH_BUILD_HOOKS_ENABLE: "1" + # Clang is less picky with the C code it's given than gcc (and may generate faster + # binaries too). + CC: clang-18 + +permissions: {} + +jobs: + configure: + runs-on: ubuntu-latest + outputs: + matrix: ${{ steps.set-config.outputs.matrix }} + + steps: + - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + with: + persist-credentials: false + + - name: Set up Python + uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0 + with: + python-version: "3.14" + pip-version: "25.3" + pip-install: --group diff-shades --group diff-shades-comment + + - name: Calculate run configuration & metadata + id: set-config + env: + GITHUB_TOKEN: ${{ github.token }} + run: python scripts/diff_shades_gha_helper.py config + + analysis-base: + name: analysis / base / ${{ matrix.mode }} + needs: configure + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + include: ${{ fromJson(needs.configure.outputs.matrix) }} + + steps: + - name: Checkout this repository (full clone) + uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + with: + # The baseline revision could be rather old so a full clone is ideal. + fetch-depth: 0 + persist-credentials: false + + - name: Set up Python + uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0 + with: + python-version: "3.14" + pip-version: "25.3" + pip-install: --group diff-shades + + - name: Configure git + run: | + git config user.name "diff-shades-gha" + git config user.email "diff-shades-gha@example.com" + + - name: Attempt to use cached baseline analysis + id: baseline-cache + uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0 + with: + path: ${{ matrix.baseline-analysis }} + key: ${{ matrix.baseline-cache-key }} + + - name: Build and install baseline revision + if: steps.baseline-cache.outputs.cache-hit != 'true' + env: + GITHUB_TOKEN: ${{ github.token }} + run: | + ${{ matrix.baseline-setup-cmd }} + python -m pip install . + + - name: Analyze baseline revision + if: steps.baseline-cache.outputs.cache-hit != 'true' + run: + diff-shades analyze ${{ matrix.baseline-analysis }} --work-dir projects-cache/ + --force-${{ matrix.style }}-style -v + + - name: Upload baseline analysis + uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 + with: + name: ${{ matrix.baseline-analysis }} + path: ${{ matrix.baseline-analysis }} + + analysis-target: + name: analysis / target / ${{ matrix.mode }} + needs: configure + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + include: ${{ fromJson(needs.configure.outputs.matrix) }} + + steps: + - name: Checkout this repository (full clone) + uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + with: + # The baseline revision could be rather old so a full clone is ideal. + fetch-depth: 0 + persist-credentials: false + + - name: Set up Python + uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0 + with: + python-version: "3.14" + pip-version: "25.3" + pip-install: --group diff-shades + + - name: Configure git + run: | + git config user.name "diff-shades-gha" + git config user.email "diff-shades-gha@example.com" + + - name: Build and install target revision + env: + GITHUB_TOKEN: ${{ github.token }} + run: | + ${{ matrix.target-setup-cmd }} + python -m pip install . + + # Pull it from previous runs - we're NOT trying to get it from this run + # (but it wouldn't cause problems if we theoretically did) + - name: Attempt to find baseline analysis + id: baseline-cache + uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0 + with: + path: ${{ matrix.baseline-analysis }} + key: ${{ matrix.baseline-cache-key }} + + - name: Analyze target revision (with repeated projects) + if: steps.baseline-cache.outputs.cache-hit == 'true' + run: | + diff-shades analyze ${{ matrix.target-analysis }} --work-dir projects-cache/ \ + --force-${{ matrix.style }}-style -v \ + --repeat-projects-from ${{ matrix.baseline-analysis }} + + - name: Analyze target revision (without repeated projects) + if: steps.baseline-cache.outputs.cache-hit != 'true' + run: + diff-shades analyze ${{ matrix.target-analysis }} --work-dir projects-cache/ + --force-${{ matrix.style }}-style -v + + - name: Upload target analysis + uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 + with: + name: ${{ matrix.target-analysis }} + path: ${{ matrix.target-analysis }} + + - name: Check for failed files for target revision + run: diff-shades show-failed --check --show-log ${{ matrix.target-analysis }} + + compare: + name: compare / ${{ matrix.mode }} + needs: ["configure", "analysis-base", "analysis-target"] + if: ${{ !cancelled() }} + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + include: ${{ fromJson(needs.configure.outputs.matrix) }} + + steps: + - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + with: + persist-credentials: false + + - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 + with: + merge-multiple: true + + - name: Set up Python + uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0 + with: + python-version: "3.14" + pip-version: "25.3" + pip-install: --group diff-shades --group diff-shades-comment + + - name: Generate HTML diff report + run: | + diff-shades --dump-html diff.html \ + compare --diff ${{ matrix.baseline-analysis }} ${{ matrix.target-analysis }} + + - name: Upload diff report + uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 + with: + name: ${{ matrix.style }}-diff.html + path: diff.html + + - name: Generate summary file (PR only) + if: github.event_name == 'pull_request' + env: + GITHUB_TOKEN: ${{ github.token }} + run: | + python scripts/diff_shades_gha_helper.py comment-body \ + ${{ matrix.baseline-analysis }} ${{ matrix.target-analysis }} \ + ${{ matrix.style }} ${{ matrix.mode }} + + - name: Upload summary file (PR only) + if: github.event_name == 'pull_request' + uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 + with: + name: .${{ matrix.style }}.pr-comment.md + path: .${{ matrix.style }}.pr-comment.md + include-hidden-files: true + + - name: Verify zero changes (PR only) + if: matrix.mode == 'assert-no-changes' + run: | + diff-shades compare --check \ + ${{ matrix.baseline-analysis }} ${{ matrix.target-analysis }} || \ + (echo "Please verify you didn't change the stable code style unintentionally!" \ + && exit 1) diff --git a/.github/workflows/diff_shades_comment.yml b/.github/workflows/diff_shades_comment.yml new file mode 100644 index 0000000..8f72107 --- /dev/null +++ b/.github/workflows/diff_shades_comment.yml @@ -0,0 +1,123 @@ +name: diff-shades comment + +on: + workflow_run: + workflows: [diff-shades] + types: [completed] + +permissions: {} + +jobs: + comment: + runs-on: ubuntu-latest + # We want to comment even if there were failed files or the stable style changed + # That would cause the main workflow to "fail" + if: + github.event.workflow_run.event == 'pull_request' && + contains(fromJSON('["success", "failure"]'), github.event.workflow_run.conclusion) + permissions: + pull-requests: write # Needed to comment on PR + steps: + - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + with: + persist-credentials: false + + - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 + id: artifacts + with: + merge-multiple: true + pattern: ".*.pr-comment.md" + path: ${{ runner.temp }}/diff-shades-artifacts + github-token: ${{ github.token }} + run-id: ${{ github.event.workflow_run.id }} + + - name: Validate downloaded comment artifacts + id: comment-artifacts + shell: bash + run: | + set -euo pipefail + + artifact_dir="${RUNNER_TEMP}/diff-shades-artifacts" + preview_artifact="${artifact_dir}/.preview.pr-comment.md" + stable_artifact="${artifact_dir}/.stable.pr-comment.md" + + if [ ! -d "$artifact_dir" ]; then + echo "::error::Artifact directory does not exist: ${artifact_dir}" + exit 1 + fi + + while IFS= read -r -d '' entry; do + if [ "$(dirname "$entry")" != "$artifact_dir" ]; then + echo "::error::Unexpected nested artifact path: ${entry}" + exit 1 + fi + + case "$(basename "$entry")" in + .preview.pr-comment.md|.stable.pr-comment.md) ;; + *) + echo "::error::Unexpected artifact path: ${entry}" + exit 1 + ;; + esac + + if [ ! -f "$entry" ] || [ -L "$entry" ]; then + echo "::error::Artifact must be a regular file: ${entry}" + exit 1 + fi + done < <(find "$artifact_dir" -mindepth 1 -print0) + + for artifact in "$preview_artifact" "$stable_artifact"; do + if [ ! -f "$artifact" ] || [ -L "$artifact" ]; then + echo "::error::Missing expected artifact file: ${artifact}" + exit 1 + fi + done + + { + echo "preview=${preview_artifact}" + echo "stable=${stable_artifact}" + } >> "$GITHUB_OUTPUT" + + - name: Set up Python + uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0 + with: + python-version: "3.14" + pip-version: "25.3" + pip-install: --group diff-shades-comment + + - name: Get PR number + id: pr + run: + echo pr=$(gh pr list --search $sha --json number --jq ".[0].number") >> + "$GITHUB_OUTPUT" + env: + GITHUB_TOKEN: ${{ github.token }} + sha: ${{ github.event.workflow_run.head_sha }} + + - name: Get details from initial workflow run + id: metadata + run: | + python scripts/diff_shades_gha_helper.py comment-details \ + "$pr" "$run_id" "$preview_artifact" "$stable_artifact" + env: + GITHUB_TOKEN: ${{ github.token }} + pr: ${{ steps.pr.outputs.pr }} + run_id: ${{ github.event.workflow_run.id }} + preview_artifact: ${{ steps.comment-artifacts.outputs.preview }} + stable_artifact: ${{ steps.comment-artifacts.outputs.stable }} + + - name: Try to find pre-existing PR comment + id: find-comment + uses: peter-evans/find-comment@b30e6a3c0ed37e7c023ccd3f1db5c6c0b0c23aad # v4.0.0 + with: + issue-number: ${{ steps.pr.outputs.pr }} + comment-author: "github-actions[bot]" + body-includes: "diff-shades" + + - name: Create or update PR comment + uses: peter-evans/create-or-update-comment@e8674b075228eee787fea43ef493e45ece1004c9 # v5.0.0 + with: + comment-id: ${{ steps.find-comment.outputs.comment-id }} + issue-number: ${{ steps.pr.outputs.pr }} + body: ${{ steps.metadata.outputs.comment-body }} + edit-mode: replace diff --git a/.github/workflows/docker.yml b/.github/workflows/docker.yml new file mode 100644 index 0000000..bd88628 --- /dev/null +++ b/.github/workflows/docker.yml @@ -0,0 +1,123 @@ +name: docker + +on: + push: + branches: + - "main" + release: + types: [published] + +permissions: + contents: read + +env: + REGISTRY: pyfound/black + +jobs: + build: + if: github.repository == 'psf/black' + runs-on: ${{ matrix.runner }} + name: build (${{ matrix.platform }}) + strategy: + matrix: + include: + - platform: linux/amd64 + runner: ubuntu-latest + - platform: linux/arm64 + runner: ubuntu-24.04-arm + steps: + - name: Checkout + uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + with: + persist-credentials: false + + - name: Set up Docker Buildx + uses: docker/setup-buildx-action@bb05f3f5519dd87d3ba754cc423b652a5edd6d2c # v4.2.0 + + - name: Login to DockerHub + uses: docker/login-action@af1e73f918a031802d376d3c8bbc3fe56130a9b0 # v4.4.0 + with: + username: ${{ secrets.DOCKERHUB_USERNAME }} + password: ${{ secrets.DOCKERHUB_TOKEN }} + + - name: Prepare + id: prepare + run: echo "platform=${platform//\//-}" >> $GITHUB_OUTPUT + env: + platform: ${{ matrix.platform }} + + - name: Build and push + id: build + uses: docker/build-push-action@53b7df96c91f9c12dcc8a07bcb9ccacbed38856a # v7.3.0 + with: + context: . + platforms: ${{ matrix.platform }} + outputs: type=image,push-by-digest=true,name-canonical=true,push=true + tags: ${{ env.REGISTRY }} + cache-from: type=gha,scope=${{ steps.prepare.outputs.platform }} + cache-to: type=gha,scope=${{ steps.prepare.outputs.platform }},mode=max + + - name: Export digest + run: | + mkdir -p digests + touch "digests/${digest#sha256:}" + env: + digest: ${{ steps.build.outputs.digest }} + + - name: Upload digest + uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 + with: + name: digests-${{ steps.prepare.outputs.platform }} + path: digests/* + if-no-files-found: error + + push: + runs-on: ubuntu-latest + needs: build + + steps: + - name: Checkout + uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + with: + persist-credentials: false + + - name: Download digests + uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 + with: + path: digests + pattern: digests-* + merge-multiple: true + + - name: Login to DockerHub + uses: docker/login-action@af1e73f918a031802d376d3c8bbc3fe56130a9b0 # v4.4.0 + with: + username: ${{ secrets.DOCKERHUB_USERNAME }} + password: ${{ secrets.DOCKERHUB_TOKEN }} + + - name: Set up Docker Buildx + uses: docker/setup-buildx-action@bb05f3f5519dd87d3ba754cc423b652a5edd6d2c # v4.2.0 + + - name: Create manifest list and push + run: | + TAGS="-t $REGISTRY:latest" + + if [[ "$EVENT_NAME" == "release" ]]; then + TAGS="$TAGS -t $REGISTRY:$(git describe --candidates=0 --tags)" + + if [[ "$PRERELEASE" == "true" ]]; then + TAGS="$TAGS -t $REGISTRY:latest_prerelease" + else + TAGS="$TAGS -t $REGISTRY:latest_release" + fi + else + TAGS="$TAGS -t $REGISTRY:latest_non_release" + fi + + cd digests + docker buildx imagetools create $TAGS $(printf "$REGISTRY@sha256:%s " *) + env: + EVENT_NAME: ${{ github.event_name }} + PRERELEASE: ${{ github.event.release.prerelease }} + + - name: Inspect image + run: docker buildx imagetools inspect $REGISTRY:latest diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml new file mode 100644 index 0000000..93a13bf --- /dev/null +++ b/.github/workflows/docs.yml @@ -0,0 +1,41 @@ +name: docs + +on: + push: + paths: ["docs/**", "src/**", "pyproject.toml", ".github/workflows/docs.yml"] + + pull_request: + paths: ["docs/**", "src/**", "pyproject.toml", ".github/workflows/docs.yml"] + +permissions: + contents: read + +jobs: + docs: + # We want to run on external PRs, but not on our own internal PRs as they'll be run + # by the push to the branch. Without this if check, checks are duplicated since + # internal PRs match both the push and pull_request events. + if: + github.event_name == 'push' || github.event.pull_request.head.repo.full_name != + github.repository + + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest, windows-latest] + + runs-on: ${{ matrix.os }} + steps: + - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + with: + persist-credentials: false + + - name: Set up Python + uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0 + with: + python-version: "3.14" + pip-version: "25.3" + pip-install: -e .[d] --group docs + + - name: Build documentation + run: sphinx-build -a -b html -W --keep-going docs/ docs/_build diff --git a/.github/workflows/fuzz.yml b/.github/workflows/fuzz.yml new file mode 100644 index 0000000..9422176 --- /dev/null +++ b/.github/workflows/fuzz.yml @@ -0,0 +1,109 @@ +name: fuzz + +on: + push: + branches: main + pull_request: + paths: + - .github/workflows/fuzz.yml + - scripts/fuzz.py + schedule: + - cron: "0 0 * * *" + workflow_dispatch: + +concurrency: + group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }} + cancel-in-progress: true + +permissions: + contents: read + +jobs: + fuzz: + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + # TODO: add 3.15; relies on libcst which doesn't support 3.15 yet + python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"] + + steps: + - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + with: + persist-credentials: false + + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0 + with: + python-version: ${{ matrix.python-version }} + allow-prereleases: true + pip-version: "25.3" + pip-install: --group tox + + - name: Run fuzz tests + id: fuzz + run: tox -e fuzz --result-json $python_ver + env: + python_ver: ${{ matrix.python-version }} + + - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 + if: failure() && steps.fuzz.outcome == 'failure' + with: + name: ${{ matrix.python-version }} + path: ${{ matrix.python-version }} + + create-issue: + runs-on: ubuntu-latest + needs: fuzz + if: + github.repository == 'psf/black' && github.event_name != 'pull_request' && + failure() + permissions: + issues: write # Needed to create issue + steps: + - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 + with: + merge-multiple: true + path: ./output + + - name: Generate issue data + run: | + output=issue-body.html + touch $output + for FILE in ./output/*; do + echo "**Python $(basename $FILE)**" >> $output + echo -e "\`\`\`py" >> $output + echo -e "# stdout:" >> $output + echo -e "$(jq .testenvs.fuzz.test[-1].output $FILE -r)\n" >> $output + echo -e "# stderr:" >> $output + echo -e "$(jq .testenvs.fuzz.test[-1].err $FILE -r)" >> $output + echo -e "\`\`\`\n" >> $output + done + + - name: Get existing issue + id: issue + run: | + echo "ISSUE=$( gh issue list \ + -A github-actions[bot] -l 'ci: fuzz error' \ + --json number -q .[0].number \ + -R $REPO )" >> $GITHUB_OUTPUT + env: + GITHUB_TOKEN: ${{ github.token }} + REPO: ${{ github.repository }} + + - name: Create new issue + if: steps.issue.outputs.ISSUE == '' + run: > + gh issue create -t "Fuzz test failure" -F issue-body.html -l "ci: fuzz error" + -R $REPO + env: + GITHUB_TOKEN: ${{ github.token }} + REPO: ${{ github.repository }} + + - name: Edit existing issue + if: steps.issue.outputs.ISSUE != '' + run: gh issue edit $ISSUE -F issue-body.html -R $REPO + env: + GITHUB_TOKEN: ${{ github.token }} + REPO: ${{ github.repository }} + ISSUE: ${{ steps.issue.outputs.ISSUE }} diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml new file mode 100644 index 0000000..57a00ab --- /dev/null +++ b/.github/workflows/lint.yml @@ -0,0 +1,46 @@ +name: lint and format + +on: [push, pull_request] + +permissions: {} + +jobs: + lint: + # We want to run on external PRs, but not on our own internal PRs as they'll be run + # by the push to the branch. Without this if check, checks are duplicated since + # internal PRs match both the push and pull_request events. + if: + github.event_name == 'push' || github.event.pull_request.head.repo.full_name != + github.repository + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + with: + persist-credentials: false + + - name: Assert PR target is main + if: github.event_name == 'pull_request' && github.repository == 'psf/black' + run: | + if [ "$GITHUB_BASE_REF" != "main" ]; then + echo "::error::PR targeting '$GITHUB_BASE_REF', please refile targeting 'main'." && exit 1 + fi + + - name: Set up Python + uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0 + with: + python-version: "3.14" + pip-version: "25.3" + pip-install: -e . --group tox + + - name: Run pre-commit hooks + uses: pre-commit/action@2c7b3805fd2a0fd8c1884dcaebf91fc102a13ecd # v3.0.1 + + - name: Format ourselves + run: tox -e run_self + + - name: Regenerate schema + run: | + tox -e generate_schema + git diff --exit-code diff --git a/.github/workflows/post_release.yml b/.github/workflows/post_release.yml new file mode 100644 index 0000000..69a573f --- /dev/null +++ b/.github/workflows/post_release.yml @@ -0,0 +1,66 @@ +name: post release + +on: + release: + types: published + +permissions: {} + +jobs: + update-stable: + runs-on: ubuntu-latest + if: github.event.release.prerelease != 'true' + permissions: + contents: write # Needed to push to stable + + steps: + - name: Checkout stable branch + uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + with: + ref: stable + fetch-depth: 0 + persist-credentials: true # needed for `git push` below + + - name: Update stable branch to release tag & push + run: | + git reset --hard "${TAG_NAME}" + git push + env: + TAG_NAME: ${{ github.event.release.tag_name }} + + new-changelog: + runs-on: ubuntu-latest + if: github.event.release.prerelease != 'true' + permissions: + contents: write # Needed to push to new branch + pull-requests: write # Needed to create PR + steps: + - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + with: + ref: main + fetch-tags: true + persist-credentials: true # Needed for git-auto-commit-action + + - name: Set up Python + uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0 + with: + python-version: "3.14" + pip-version: "25.3" + + - run: python scripts/release.py -a + + - uses: stefanzweifel/git-auto-commit-action@4a55954c782fc1ea30b9056cd3e7a2b40ca8887d # v7.2.0 + with: + commit_message: Add new changelog + branch: ci/new-changelog + create_branch: true + + - name: Create PR + run: | + gh pr create \ + -t "Add new changelog" -b "" \ + -l "ci: skip news" -l "C: maintenance" \ + -a $USER + env: + GITHUB_TOKEN: ${{ github.token }} + USER: ${{ github.event.release.author.login }} diff --git a/.github/workflows/publish_binaries.yml b/.github/workflows/publish_binaries.yml new file mode 100644 index 0000000..3de10c7 --- /dev/null +++ b/.github/workflows/publish_binaries.yml @@ -0,0 +1,77 @@ +name: publish binaries + +on: + release: + types: [published] + workflow_dispatch: + inputs: + tag: + required: true + type: string + +permissions: {} + +jobs: + publish: + name: publish (${{ matrix.os }}) + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + include: + - os: windows-latest + pathsep: ";" + asset_name: black_windows.exe + executable_mime: "application/vnd.microsoft.portable-executable" + strip: false + - os: windows-11-arm + pathsep: ";" + asset_name: black_windows-arm.exe + executable_mime: "application/vnd.microsoft.portable-executable" + strip: false + - os: ubuntu-latest + pathsep: ":" + asset_name: black_linux + executable_mime: "application/x-executable" + strip: true + - os: ubuntu-24.04-arm + pathsep: ":" + asset_name: black_linux-arm + executable_mime: "application/x-executable" + strip: true + - os: macos-latest + pathsep: ":" + asset_name: black_macos + executable_mime: "application/x-mach-binary" + strip: false + permissions: + contents: write # Needed to upload to release + + steps: + - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + with: + persist-credentials: false + + - name: Set up Python + uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0 + with: + python-version: "3.14" + pip-version: "25.3" + pip-install: .[colorama] --group pyinstaller + + - name: Build executable with PyInstaller + run: + python -m PyInstaller -F ${{ matrix.strip && '--strip' || '' }} --name ${{ + matrix.asset_name }} --add-data 'src/blib2to3${{ matrix.pathsep }}blib2to3' + src/black/__main__.py + + - name: Quickly test executable + run: | + ./dist/${{ matrix.asset_name }} --version + ./dist/${{ matrix.asset_name }} src --verbose + + - run: gh release upload "$tag" dist/${{ matrix.asset_name }} + shell: bash + env: + GH_TOKEN: ${{ github.token }} + tag: ${{ inputs.tag || github.event.release.tag_name }} diff --git a/.github/workflows/pypi_upload.yml b/.github/workflows/pypi_upload.yml new file mode 100644 index 0000000..0390938 --- /dev/null +++ b/.github/workflows/pypi_upload.yml @@ -0,0 +1,160 @@ +name: build and publish + +on: + release: + types: published + pull_request: + push: + branches: main + +permissions: {} + +env: + PROJECT: https://pypi.org/p/black + +jobs: + configure: + name: generate wheels matrix + runs-on: ubuntu-latest + outputs: + include: ${{ steps.set-matrix.outputs.include }} + steps: + - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + with: + persist-credentials: false + + - name: Set up Python + uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0 + with: + python-version: "3.14" + pip-version: "25.3" + pip-install: --group cibw + + - name: generate matrix + if: | + github.event_name != 'pull_request' || contains(github.event.pull_request.labels.*.name, 'ci: build all wheels') + run: | + { + cibuildwheel --print-build-identifiers --platform linux \ + | pyp 'json.dumps({"only": x, "os": "ubuntu-latest"})' \ + && cibuildwheel --print-build-identifiers --platform macos \ + | pyp 'json.dumps({"only": x, "os": "macos-latest"})' \ + && cibuildwheel --print-build-identifiers --platform windows \ + | pyp 'json.dumps({"only": x, "os": "windows-latest"})' \ + && cibuildwheel --print-build-identifiers --platform windows --archs ARM64 \ + | pyp 'json.dumps({"only": x, "os": "windows-11-arm"})' + } | pyp 'json.dumps(list(map(json.loads, lines)))' > /tmp/matrix + env: + CIBW_ARCHS_LINUX: x86_64 + CIBW_ARCHS_MACOS: x86_64 arm64 + CIBW_ARCHS_WINDOWS: AMD64 + + - name: generate matrix (PR) + if: | + github.event_name == 'pull_request' && !contains(github.event.pull_request.labels.*.name, 'ci: build all wheels') + run: | + { + CIBW_BUILD="cp310-*" cibuildwheel --print-build-identifiers --platform linux | pyp 'json.dumps({"only": x, "os": "ubuntu-latest"})' + CIBW_BUILD="cp314-*" cibuildwheel --print-build-identifiers --platform windows | pyp 'json.dumps({"only": x, "os": "windows-latest"})' + } | pyp 'json.dumps(list(map(json.loads, lines)))' > /tmp/matrix + env: + CIBW_ARCHS_LINUX: x86_64 + + - id: set-matrix + run: echo "include=$(cat /tmp/matrix)" | tee -a $GITHUB_OUTPUT + + mypyc: + name: mypyc wheels ${{ matrix.only }} + needs: configure + runs-on: ${{ matrix.os }} + strategy: + matrix: + include: ${{ fromJson(needs.configure.outputs.include) }} + + steps: + - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + with: + persist-credentials: false + + - name: Set up Python + uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0 + with: + python-version: "3.14" + pip-version: "25.3" + pip-install: --group cibw + + - name: Run cibuildwheel + run: cibuildwheel . --only ${{ matrix.only }} + + - name: Upload wheels as workflow artifacts + uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 + with: + name: ${{ matrix.only }}-mypyc-wheels + path: wheelhouse/ + + hatch: + name: sdist + pure wheel + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + with: + persist-credentials: false + + - name: Set up Python + uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0 + with: + python-version: "3.14" + pip-version: "25.3" + pip-install: --group hatch + + - name: Build wheel and source distributions + run: python -m hatch build + + - name: Store the distribution packages + uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 + with: + name: sdist-and-pure-wheel + path: dist/ + + publish-mypyc: + if: github.event_name == 'release' + needs: mypyc + runs-on: ubuntu-latest + environment: + name: release + url: ${{ env.PROJECT }} + permissions: + id-token: write # Required for PyPI trusted publishing + steps: + - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 + with: + pattern: "*-mypyc-wheels" + path: wheelhouse/ + merge-multiple: true + + - name: Publish package distributions to PyPI + uses: pypa/gh-action-pypi-publish@cef221092ed1bacb1cc03d23a2d87d1d172e277b # v1.14.0 + with: + packages-dir: wheelhouse/ + verbose: true + + publish-hatch: + if: github.event_name == 'release' + needs: hatch + runs-on: ubuntu-latest + environment: + name: release + url: ${{ env.PROJECT }} + permissions: + id-token: write # Required for PyPI trusted publishing + steps: + - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 + with: + name: sdist-and-pure-wheel + path: dist/ + + - name: Publish package distributions to PyPI + uses: pypa/gh-action-pypi-publish@cef221092ed1bacb1cc03d23a2d87d1d172e277b # v1.14.0 + with: + verbose: true diff --git a/.github/workflows/release_tests.yml b/.github/workflows/release_tests.yml new file mode 100644 index 0000000..0d2e6c9 --- /dev/null +++ b/.github/workflows/release_tests.yml @@ -0,0 +1,59 @@ +name: test release tool + +on: + push: + paths: + - .github/workflows/release_tests.yml + - scripts/release.py + - scripts/release_tests.py + pull_request: + paths: + - .github/workflows/release_tests.yml + - scripts/release.py + - scripts/release_tests.py + +permissions: {} + +jobs: + test-release-tool: + # We want to run on external PRs, but not on our own internal PRs as they'll be run + # by the push to the branch. Without this if check, checks are duplicated since + # internal PRs match both the push and pull_request events. + if: + github.event_name == 'push' || github.event.pull_request.head.repo.full_name != + github.repository + + runs-on: ${{ matrix.os }} + strategy: + matrix: + python-version: ["3.12", "3.13", "3.14", "3.15"] + os: [macOS-latest, ubuntu-latest, windows-latest] + + steps: + - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + with: + # Give us all history, branches and tags + fetch-depth: 0 + persist-credentials: false + + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0 + with: + python-version: ${{ matrix.python-version }} + allow-prereleases: true + pip-version: "25.3" + pip-install: --group coverage + + - name: Print Python Version + run: python --version --version && which python + + - name: Print Pip Version + run: pip --version && which pip + + - name: Print Git Version + run: git --version && which git + + - name: Run unit tests via coverage + print report + run: | + coverage run scripts/release_tests.py + coverage report --show-missing diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml new file mode 100644 index 0000000..7f7f1dc --- /dev/null +++ b/.github/workflows/test.yml @@ -0,0 +1,124 @@ +name: test + +on: + push: + paths: + - .github/workflows/test.yml + - src/** + - tests/** + - tox.ini + - pyproject.toml + + pull_request: + paths: + - .github/workflows/test.yml + - src/** + - tests/** + - tox.ini + - pyproject.toml + +permissions: + contents: read + +concurrency: + group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.run_id }} + cancel-in-progress: true + +jobs: + test: + # We want to run on external PRs, but not on our own internal PRs as they'll be run + # by the push to the branch. Without this if check, checks are duplicated since + # internal PRs match both the push and pull_request events. + if: + github.event_name == 'push' || github.event.pull_request.head.repo.full_name != + github.repository + + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + python-version: + ["3.10", "3.11", "3.12.10", "3.13", "3.14", "3.15", "pypy3.11-v7.3.22"] + os: [ubuntu-latest, macOS-latest, windows-latest, windows-11-arm] + exclude: + # setup-python only supports CPython 3.11+ on arm64 windows + - os: windows-11-arm + python-version: "3.10" + - os: windows-11-arm + python-version: "pypy3.11-v7.3.22" + + steps: + - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + with: + persist-credentials: false + + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0 + with: + python-version: ${{ matrix.python-version }} + allow-prereleases: true + pip-version: "25.3" + pip-install: --group tox + + - name: Unit tests + if: "!startsWith(matrix.python-version, 'pypy')" + run: + tox -e ci-py$(echo ${{ matrix.python-version }} | tr -d '.') -- -v --color=yes + + - name: Unit tests (pypy) + if: "startsWith(matrix.python-version, 'pypy')" + run: tox -e ci-pypy3 -- -v --color=yes + + - name: Upload coverage to Coveralls + # Upload coverage if we are on the main repository and + # we're running on Linux (this action only supports Linux) + if: + github.repository == 'psf/black' && matrix.os == 'ubuntu-latest' && + !startsWith(matrix.python-version, 'pypy') + uses: AndreMiras/coveralls-python-action@ac868b9540fad490f7ca82b8ca00480fd751ed19 + with: + github-token: ${{ secrets.GITHUB_TOKEN }} + parallel: true + flag-name: py${{ matrix.python-version }}-${{ matrix.os }} + debug: true + + coveralls-finish: + needs: test + if: github.repository == 'psf/black' + + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + with: + persist-credentials: false + + - name: Send finished signal to Coveralls + uses: AndreMiras/coveralls-python-action@ac868b9540fad490f7ca82b8ca00480fd751ed19 + with: + parallel-finished: true + debug: true + + uvloop: + if: + github.event_name == 'push' || github.event.pull_request.head.repo.full_name != + github.repository + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest, macOS-latest, windows-latest, windows-11-arm] + + steps: + - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + with: + persist-credentials: false + + - name: Set up Python + uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0 + with: + python-version: "3.14" + pip-version: "25.3" + pip-install: -e .[uvloop] + + - name: Format ourselves + run: python -m black --check . diff --git a/.github/workflows/zizmor.yml b/.github/workflows/zizmor.yml new file mode 100644 index 0000000..71cdd8b --- /dev/null +++ b/.github/workflows/zizmor.yml @@ -0,0 +1,25 @@ +name: zizmor + +on: + push: + branches: ["main"] + paths: ["**.yml"] + pull_request: + paths: ["**.yml"] + +permissions: {} + +jobs: + zizmor: + name: zizmor + runs-on: ubuntu-latest + permissions: + security-events: write # Required for upload-sarif (used by zizmor-action) to upload SARIF files. + steps: + - name: Checkout repository + uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 + with: + persist-credentials: false + + - name: Run zizmor + uses: zizmorcore/zizmor-action@192e21d79ab29983730a13d1382995c2307fbcaa # v0.5.7 diff --git a/.github/zizmor.yml b/.github/zizmor.yml new file mode 100644 index 0000000..d52a391 --- /dev/null +++ b/.github/zizmor.yml @@ -0,0 +1,8 @@ +rules: + dangerous-triggers: + ignore: + # The diff-shades comment workflow intentionally runs after the unprivileged + # diff-shades workflow so it can publish the generated PR comment. It must + # treat artifacts as untrusted and only read validated files from an isolated + # artifact directory. + - diff_shades_comment.yml diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..5d280e4 --- /dev/null +++ b/.gitignore @@ -0,0 +1,29 @@ +.venv +.coverage +.coverage.* +_build +.DS_Store +.vscode +.python-version +docs/_static/pypi.svg +.tox +__pycache__ + +# Packaging artifacts +black.egg-info +black.dist-info +build/ +dist/ +pip-wheel-metadata/ +.eggs + +src/_black_version.py +.idea + +.dmypy.json +*.swp +.hypothesis/ +venv/ +.ipynb_checkpoints/ +node_modules/ +*.pyd diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..0cc8cc4 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,85 @@ +# Note: don't use this config for your own repositories. Instead, see +# "Version control integration" in docs/integrations/source_version_control.md +exclude: ^(profiling/|tests/data/) +repos: + - repo: local + hooks: + - id: check-pre-commit-rev-in-example + name: Check pre-commit rev in example + language: python + entry: python -m scripts.check_pre_commit_rev_in_example + files: '(CHANGES|source_version_control|using_black_with_jupyter_notebooks)\.md$' + additional_dependencies: + - beautifulsoup4>=4.14.2 + - commonmark>=0.9.1 + - pyyaml>=6.0.1 + + - id: check-version-in-the-basics-example + name: Check black version in the basics example + language: python + entry: python -m scripts.check_version_in_basics_example + files: '(CHANGES|the_basics)\.md$' + additional_dependencies: + - beautifulsoup4>=4.14.2 + - commonmark>=0.9.1 + + - repo: https://github.com/pycqa/isort + rev: 8.0.1 + hooks: + - id: isort + + - repo: https://github.com/pycqa/flake8 + rev: 7.3.0 + hooks: + - id: flake8 + additional_dependencies: + - flake8-bugbear + - flake8-comprehensions + - flake8-simplify + exclude: ^src/blib2to3/ + + - repo: https://github.com/pre-commit/mirrors-mypy + rev: v1.20.2 + hooks: + - id: mypy + exclude: ^docs/conf.py$ + args: [] + additional_dependencies: + - click>=8.0.0 + - packaging>=22.0 + - platformdirs>=2 + - pytokens~=0.4.0 + - tomli>=1.1.0 + - uvloop>=0.15.2; sys_platform != 'win32' + - winloop>=0.5.0; sys_platform == 'win32' + + # blackd + - aiohttp>=3.10 + + # tests + - pytest>=7 + + # fuzz + - hypothesis + - hypothesmith + - types-atheris + + # diff-shades + - urllib3 + + # version check + - beautifulsoup4>=4.14.2 + - types-commonmark>=0.9.0 + - types-pyyaml>=6.0.0 + + - repo: https://github.com/rbubley/mirrors-prettier + rev: v3.8.3 + hooks: + - id: prettier + types_or: [markdown, yaml, json] + + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v6.0.0 + hooks: + - id: end-of-file-fixer + - id: trailing-whitespace diff --git a/.pre-commit-hooks.yaml b/.pre-commit-hooks.yaml new file mode 100644 index 0000000..a1ff41f --- /dev/null +++ b/.pre-commit-hooks.yaml @@ -0,0 +1,20 @@ +# Note that we recommend using https://github.com/psf/black-pre-commit-mirror instead +# This will work about 2x as fast as using the hooks in this repository +- id: black + name: black + description: "Black: The uncompromising Python code formatter" + entry: black + language: python + minimum_pre_commit_version: 2.9.2 + require_serial: true + types_or: [python, pyi] +- id: black-jupyter + name: black-jupyter + description: + "Black: The uncompromising Python code formatter (with Jupyter Notebook support)" + entry: black + language: python + minimum_pre_commit_version: 2.9.2 + require_serial: true + types_or: [python, pyi, jupyter] + additional_dependencies: [".[jupyter]"] diff --git a/.prettierrc.yaml b/.prettierrc.yaml new file mode 100644 index 0000000..fe1f7e0 --- /dev/null +++ b/.prettierrc.yaml @@ -0,0 +1,9 @@ +proseWrap: always +printWidth: 88 +endOfLine: auto +overrides: + - files: + - ".github/ISSUE_TEMPLATE/*.md" + - ".github/PULL_REQUEST_TEMPLATE.md" + options: + proseWrap: never diff --git a/.readthedocs.yaml b/.readthedocs.yaml new file mode 100644 index 0000000..231cc84 --- /dev/null +++ b/.readthedocs.yaml @@ -0,0 +1,17 @@ +version: 2 + +formats: + - htmlzip + +build: + os: ubuntu-lts-latest + tools: + python: "3.13" + jobs: + install: + - pip install --upgrade pip + - pip install .[d] + - pip install --group docs + +sphinx: + configuration: docs/conf.py diff --git a/AUTHORS.md b/AUTHORS.md new file mode 100644 index 0000000..f6ab6ab --- /dev/null +++ b/AUTHORS.md @@ -0,0 +1,198 @@ +# Authors + +Glued together by [Łukasz Langa](mailto:lukasz@langa.pl). + +Maintained with: + +- [Carol Willing](mailto:carolcode@willingconsulting.com) +- [Carl Meyer](mailto:carl@oddbird.net) +- [Jelle Zijlstra](mailto:jelle.zijlstra@gmail.com) +- [Mika Naylor](mailto:mail@autophagy.io) +- [Zsolt Dollenstein](mailto:zsol.zsol@gmail.com) +- [Cooper Lees](mailto:me@cooperlees.com) +- [Richard Si](mailto:sichard26@gmail.com) +- [Felix Hildén](mailto:felix.hilden@gmail.com) +- [Batuhan Taskaya](mailto:batuhan@python.org) +- [Shantanu Jain](mailto:hauntsaninja@gmail.com) + +Multiple contributions by: + +- [Abdur-Rahmaan Janhangeer](mailto:arj.python@gmail.com) +- [Adam Johnson](mailto:me@adamj.eu) +- [Adam Williamson](mailto:adamw@happyassassin.net) +- [Alexander Huynh](mailto:ahrex-gh-psf-black@e.sc) +- [Alexandr Artemyev](mailto:mogost@gmail.com) +- [Alex Vandiver](mailto:github@chmrr.net) +- [Allan Simon](mailto:allan.simon@supinfo.com) +- Anders-Petter Ljungquist +- [Amethyst Reese](mailto:amy@n7.gg) +- [Andrew Thorp](mailto:andrew.thorp.dev@gmail.com) +- [Andrew Zhou](mailto:andrewfzhou@gmail.com) +- [Andrey](mailto:dyuuus@yandex.ru) +- [Andy Freeland](mailto:andy@andyfreeland.net) +- [Anthony Sottile](mailto:asottile@umich.edu) +- [Antonio Ossa Guerra](mailto:aaossa+black@uc.cl) +- [Arjaan Buijk](mailto:arjaan.buijk@gmail.com) +- [Arnav Borbornah](mailto:arnavborborah11@gmail.com) +- [Artem Malyshev](mailto:proofit404@gmail.com) +- [Asger Hautop Drewsen](mailto:asgerdrewsen@gmail.com) +- [Augie Fackler](mailto:raf@durin42.com) +- [Aviskar KC](mailto:aviskarkc10@gmail.com) +- Batuhan Taşkaya +- [Benjamin Wohlwend](mailto:bw@piquadrat.ch) +- [Benjamin Woodruff](mailto:github@benjam.info) +- [Bharat Raghunathan](mailto:bharatraghunthan9767@gmail.com) +- [Brandt Bucher](mailto:brandtbucher@gmail.com) +- [Brett Cannon](mailto:brett@python.org) +- [Bryan Bugyi](mailto:bryan.bugyi@rutgers.edu) +- [Bryan Forbes](mailto:bryan@reigndropsfall.net) +- [Calum Lind](mailto:calumlind@gmail.com) +- [Charles](mailto:peacech@gmail.com) +- Charles Reid +- [Christian Clauss](mailto:cclauss@bluewin.ch) +- [Christian Heimes](mailto:christian@python.org) +- [Chuck Wooters](mailto:chuck.wooters@microsoft.com) +- [Chris Rose](mailto:offline@offby1.net) +- Codey Oxley +- [Cong](mailto:congusbongus@gmail.com) +- [Cooper Ry Lees](mailto:me@cooperlees.com) +- [Dan Davison](mailto:dandavison7@gmail.com) +- [Daniel Hahler](mailto:github@thequod.de) +- [Daniel M. Capella](mailto:polycitizen@gmail.com) +- Daniele Esposti +- [David Hotham](mailto:david.hotham@metaswitch.com) +- [David Lukes](mailto:dafydd.lukes@gmail.com) +- [David Szotten](mailto:davidszotten@gmail.com) +- [Denis Laxalde](mailto:denis@laxalde.org) +- [Douglas Thor](mailto:dthor@transphormusa.com) +- dylanjblack +- [Eli Treuherz](mailto:eli@treuherz.com) +- [Emil Hessman](mailto:emil@hessman.se) +- [Felix Kohlgrüber](mailto:felix.kohlgrueber@gmail.com) +- [Florent Thiery](mailto:fthiery@gmail.com) +- Francisco +- [Giacomo Tagliabue](mailto:giacomo.tag@gmail.com) +- [Greg Gandenberger](mailto:ggandenberger@shoprunner.com) +- [Gregory P. Smith](mailto:greg@krypto.org) +- Gustavo Camargo +- hauntsaninja +- [Hadi Alqattan](mailto:alqattanhadizaki@gmail.com) +- [Hassan Abouelela](mailto:hassan@hassanamr.com) +- [Heaford](mailto:dan@heaford.com) +- [Hugo Barrera](mailto:hugo@barrera.io) +- Hugo van Kemenade +- [Hynek Schlawack](mailto:hs@ox.cx) +- [Ionite](mailto:dev@ionite.io) +- [Ivan Katanić](mailto:ivan.katanic@gmail.com) +- [Jakub Kadlubiec](mailto:jakub.kadlubiec@skyscanner.net) +- [Jakub Warczarek](mailto:jakub.warczarek@gmail.com) +- [Jan Hnátek](mailto:jan.hnatek@gmail.com) +- [Jason Fried](mailto:me@jasonfried.info) +- [Jason Friedland](mailto:jason@friedland.id.au) +- [jgirardet](mailto:ijkl@netc.fr) +- Jim Brännlund +- [Jimmy Jia](mailto:tesrin@gmail.com) +- [Joe Antonakakis](mailto:jma353@cornell.edu) +- [Jon Dufresne](mailto:jon.dufresne@gmail.com) +- [Jonas Obrist](mailto:ojiidotch@gmail.com) +- [Jonty Wareing](mailto:jonty@jonty.co.uk) +- [Jose Nazario](mailto:jose.monkey.org@gmail.com) +- [Joseph Larson](mailto:larson.joseph@gmail.com) +- [Josh Bode](mailto:joshbode@fastmail.com) +- [Josh Holland](mailto:anowlcalledjosh@gmail.com) +- [Joshua Cannon](mailto:joshdcannon@gmail.com) +- [José Padilla](mailto:jpadilla@webapplicate.com) +- [Juan Luis Cano Rodríguez](mailto:hello@juanlu.space) +- [kaiix](mailto:kvn.hou@gmail.com) +- [Katie McLaughlin](mailto:katie@glasnt.com) +- Katrin Leinweber +- [Keith Smiley](mailto:keithbsmiley@gmail.com) +- [Kenyon Ralph](mailto:kenyon@kenyonralph.com) +- [Kevin Kirsche](mailto:Kev.Kirsche+GitHub@gmail.com) +- [Kyle Hausmann](mailto:kyle.hausmann@gmail.com) +- [Kyle Sunden](mailto:sunden@wisc.edu) +- Lawrence Chan +- [Linus Groh](mailto:mail@linusgroh.de) +- [Loren Carvalho](mailto:comradeloren@gmail.com) +- [Luka Sterbic](mailto:luka.sterbic@gmail.com) +- [LukasDrude](mailto:mail@lukas-drude.de) +- Mahmoud Hossam +- Mariatta +- [Matt VanEseltine](mailto:vaneseltine@gmail.com) +- [Matthew Clapp](mailto:itsayellow+dev@gmail.com) +- [Matthew Walster](mailto:matthew@walster.org) +- Max Smolens +- [Michael Aquilina](mailto:michaelaquilina@gmail.com) +- [Michael Flaxman](mailto:michael.flaxman@gmail.com) +- [Michael J. Sullivan](mailto:sully@msully.net) +- [Michael McClimon](mailto:michael@mcclimon.org) +- [Miguel Gaiowski](mailto:miggaiowski@gmail.com) +- [Mike](mailto:roshi@fedoraproject.org) +- [mikehoyio](mailto:mikehoy@gmail.com) +- [Min ho Kim](mailto:minho42@gmail.com) +- [Miroslav Shubernetskiy](mailto:miroslav@miki725.com) +- MomIsBestFriend +- [Nathan Goldbaum](mailto:ngoldbau@illinois.edu) +- [Nathan Hunt](mailto:neighthan.hunt@gmail.com) +- [Neraste](mailto:neraste.herr10@gmail.com) +- [Nikolaus Waxweiler](mailto:madigens@gmail.com) +- [Ofek Lev](mailto:ofekmeister@gmail.com) +- [Osaetin Daniel](mailto:osaetindaniel@gmail.com) +- [otstrel](mailto:otstrel@gmail.com) +- [Pablo Galindo](mailto:Pablogsal@gmail.com) +- [Paul Ganssle](mailto:p.ganssle@gmail.com) +- [Paul Meinhardt](mailto:mnhrdt@gmail.com) +- [Paul S. Reid](mailto:paul@reid-family.org) +- [Peter Bengtsson](mailto:mail@peterbe.com) +- [Peter Grayson](mailto:pete@jpgrayson.net) +- [Peter Stensmyr](mailto:peter.stensmyr@gmail.com) +- pmacosta +- [Quentin Pradet](mailto:quentin@pradet.me) +- [Ralf Schmitt](mailto:ralf@systemexit.de) +- [Ramón Valles](mailto:mroutis@protonmail.com) +- [Richard Fearn](mailto:richardfearn@gmail.com) +- [Rishikesh Jha](mailto:rishijha424@gmail.com) +- [Rupert Bedford](mailto:rupert@rupertb.com) +- Russell Davis +- [Sagi Shadur](mailto:saroad2@gmail.com) +- [Rémi Verschelde](mailto:rverschelde@gmail.com) +- [Sami Salonen](mailto:sakki@iki.fi) +- [Samuel Cormier-Iijima](mailto:samuel@cormier-iijima.com) +- [Sanket Dasgupta](mailto:sanketdasgupta@gmail.com) +- Sergi +- [Scott Stevenson](mailto:scott@stevenson.io) +- Shantanu +- [shaoran](mailto:shaoran@sakuranohana.org) +- [Shinya Fujino](mailto:shf0811@gmail.com) +- springstan +- [Stavros Korokithakis](mailto:hi@stavros.io) +- [Stephen Rosen](mailto:sirosen@globus.org) +- [Steven M. Vascellaro](mailto:S.Vascellaro@gmail.com) +- [Sunil Kapil](mailto:snlkapil@gmail.com) +- [Sébastien Eustace](mailto:sebastien.eustace@gmail.com) +- [Tal Amuyal](mailto:TalAmuyal@gmail.com) +- [Terrance](mailto:git@terrance.allofti.me) +- [Thom Lu](mailto:thomas.c.lu@gmail.com) +- [Thomas Grainger](mailto:tagrain@gmail.com) +- [Tim Gates](mailto:tim.gates@iress.com) +- [Tim Swast](mailto:swast@google.com) +- [Timo](mailto:timo_tk@hotmail.com) +- Toby Fleming +- [Tom Christie](mailto:tom@tomchristie.com) +- [Tony Narlock](mailto:tony@git-pull.com) +- [Tsuyoshi Hombashi](mailto:tsuyoshi.hombashi@gmail.com) +- [Tushar Chandra](mailto:tusharchandra2018@u.northwestern.edu) +- [Tushar Sadhwani](mailto:tushar.sadhwani000@gmail.com) +- [Tzu-ping Chung](mailto:uranusjr@gmail.com) +- [Utsav Shah](mailto:ukshah2@illinois.edu) +- utsav-dbx +- vezeli +- [Ville Skyttä](mailto:ville.skytta@iki.fi) +- [Vishwas B Sharma](mailto:sharma.vishwas88@gmail.com) +- [Vlad Emelianov](mailto:volshebnyi@gmail.com) +- [williamfzc](mailto:178894043@qq.com) +- [wouter bolsterlee](mailto:wouter@bolsterl.ee) +- Yazdan +- [Yngve Høiseth](mailto:yngve@hoiseth.net) +- [Yurii Karabas](mailto:1998uriyyo@gmail.com) +- [Zac Hatfield-Dodds](mailto:zac@zhd.dev) diff --git a/CHANGES.md b/CHANGES.md new file mode 100644 index 0000000..bfe4cae --- /dev/null +++ b/CHANGES.md @@ -0,0 +1,2426 @@ +# Change Log + +## Unreleased + + + +- Add support for NO_COLOR environment variable to disable ANSI output (#5129) +- No spurious target version warning when runtime version is included in a + --target-version flag (#5167) + +### Highlights + + + +### Stable style + + + +- Fix crash when a standalone comment sits between tokens of a comprehension or lambda + (#5144) +- Fix crash when a comment-only `# fmt: off`/`# fmt: on` block is followed by a `with` + statement after another standalone comment (#5189) +- Fix a crash when splitting `case case if ...` match patterns at very small line + lengths (#5147) +- Fix multiline docstring indentation when leading tabs are used inside indented + docstrings (#5148) +- Respect `# fmt: skip` on a line that opens a bracket (e.g. + `from x import ( # fmt: skip`) when a standalone comment is among the bracket's + contents: the whole statement is now preserved instead of being reformatted (and + previously crashing) (#5161) + +### Preview style + + + +- Fix unnecessary parentheses around short RHS expressions in indexed assignments like + `x[key] = expr` (#5095) +- Parenthesize tuple expressions in `yield` statements for consistency with function + calls and returns (#5170) +- Stop splitting between a variable and its comparator (`not in`, `==`, `is`, ...) when + the right-hand side is a bracketed expression. Black now lets the bracket explode + instead. This fixes the awkward break that was showing up in comprehension `if` + clauses (#4514) as well as the same shape inside `if`, `elif`, `assert`, and + parenthesized expressions (#5135) +- In `.pyi` stub files, enforce a blank line after a function or method that has a + docstring-only body when another comment or statement follows it (#5158) +- Keep the parentheses around a lambda used as the iterable of a comprehension (e.g. + `[x for x in (lambda: 0) if x]`). They were previously stripped by + `wrap_comprehension_in`, which produced invalid code and crashed Black (#5176) + +### Configuration + + + +- Fix `find_project_root` returning a stale cached result when `--code` is used from + different working directories in the same process. The CWD fallback (used when no + `srcs` are given) is now resolved before the `lru_cache` key is computed, so each + directory gets the correct `pyproject.toml` (#5152) +- Add validation for --line-ranges values (#5107) +- Ignore empty cache files like other malformed cache files instead of raising an + `EOFError` (#5192) +- Reject non-string `include` and `force-exclude` values in `pyproject.toml` (#5193) +- Validate `BLACK_NUM_WORKERS` values and report invalid values as usage errors instead + of crashing (#5211) + +### Packaging + + + +- Reduce the size of Linux standalone binaries by stripping debug symbols during the + PyInstaller release build (#5223) + +### Parser + + + +### Performance + + + +- Improve performance on strings containing many consecutive backslashes (#5163) +- Improve performance when merging implicitly concatenated f-strings whose expressions + contain long string literals (#5165) +- Improve performance on files with many `# fmt: skip`/`# fmt: off` comments by no + longer re-walking the whole tree from the root for every directive (#5169) +- Improve performance on deeply nested parenthesised expressions by no longer + re-scanning the whole atom for every nesting level in `max_delimiter_priority_in_atom` + (#5171) +- Improve performance when merging long runs of implicitly concatenated strings by no + longer re-escaping the whole accumulated string on every merge step (#5173) + sibling-maps-incremental +- Improve performance on code whose formatting rewrites large nodes (such as `--preview` + string processing) by maintaining the `blib2to3` sibling-node maps incrementally + rather than rebuilding them from scratch after every tree mutation (#5178) +- Improve performance on long calls and collections by no longer scanning the whole line + to locate each bracket's opening pair in `is_one_sequence_between` (#5177) +- Improve performance on functions and other blocks containing many `# fmt: skip` + comments by no longer scanning every leaf of the enclosing block for each directive + when checking for a semicolon-separated inline body (#5190) +- Improve performance when merging large groups of implicitly concatenated strings by no + longer rebuilding a node's children list and sibling maps from scratch on every + `replace` call (#5194) +- Improve performance on lines holding a multiline string inside a large collection (for + example a dict literal whose values are all triple-quoted strings) by locating the + string's enclosing nodes via leaf membership instead of re-rendering each enclosing + node to a string in `is_line_short_enough` (#5188) +- Improve performance on files with many soft-keyword constructs (such as `match`/`case` + blocks) by discarding spent token-lookahead ranges in the parser instead of + re-scanning all of them for every token (#5186) +- Improve performance when splitting long string literals (preview string processing) by + no longer re-scanning the whole string for `\N{...}` named escapes on every substring + (#5183) +- Improve performance on large dict literals and long semicolon-separated statements by + wrapping a node's children in invisible parentheses in place instead of removing and + re-inserting each one, which scanned the whole child list every time (#5184) +- Improve performance when copying a long line's leaves into a new line (for example + `--preview` string processing of `"%s ..." % (a, b, c, ...)` or a string with a + backslash continuation) by resuming the child lookup in `append_leaves` instead of + rescanning each leaf's parent from the start (#5199) +- Improve performance of `--line-ranges` on files with many sibling blocks (a long + `if`/`elif` chain, a `match` with many cases, or many top-level definitions) by + splicing the unchanged blocks into each parent's child list in a single pass rather + than removing and re-inserting each one, which rescanned and shifted the whole child + list on every conversion (#5213) +- Improve performance on files with many `# fmt: off`/`# fmt: on` blocks by resuming the + search for each converted block within its parent's child list from the previous + conversion's position instead of rescanning the whole list from the start on every + node removal (#5232) + +### Output + + + +### _Blackd_ + + + +### Integrations + + + +### Documentation + + + +## Version 26.5.1 + +### Stable style + +- Fix unstable formatting of annotated assignments whose subscript annotation contains + an inline comment (e.g. `x: list[ # pyright: ignore[...]`) (#5130) +- Preserve inline comments (including `# type: ignore`) immediately before a + `# fmt: skip` line, avoiding AST equivalence failures (#5139) + +### Packaging + +- Correct the version in the published executables (#5137) + +### Documentation + +- Add Neovim integration guide covering conform.nvim, ALE, and simple command approaches + (#5124) + +## Version 26.5.0 + +### Highlights + +- Add support for unpacking in comprehensions (PEP 798) and for lazy imports (PEP 810), + both new syntactic features in Python 3.15 (#5048) +- Python 3.15 is now supported. Compiled wheels are not yet provided for Python 3.15, so + performance may be slower than on existing Python versions. Wheels will be provided + once Python 3.15 is later in its release cycle. (#5127) + +### Stable style + +- Fix `# fmt: skip` being ignored in nested `if` expressions with parenthesized `in` + clauses (#4903) +- Add syntactic support for Python 3.15 (#5048) +- Fix crash when an f-string follows a `# fmt: off` comment inside brackets (#5097) +- Preserve multiline compound statement headers when `# fmt: skip` is placed on the + colon line (#5117) + +### Preview style + +- Improve heuristics around whether blank lines should appear before, within and after + groups of same-name decorated functions (such as `@overload` groups) in `.pyi` stub + files (#5021) +- Fix blank lines being removed between a function and a decorated class in `.pyi` stub + files (#5092) +- Prevent string merger from creating unsplittable long lines when a pragma comment + (e.g. `# type: ignore`) follows the closing bracket (#5096) + +### Packaging + +- Run CI on 3.15 (#5127) + +### Output + +- Improve parse error readability by showing multi-line output with an error pointer. + (#5068) +- Add `SourceASTParseError` to distinguish source parse failures from internal safety + errors, improving error reporting when Black's lenient parser accepts input that + `ast.parse()` rejects (#5080) + +### _Blackd_ + +- Return HTTP 400 (Bad Request) for source parse failures instead of HTTP 500, keeping + HTTP 500 only for genuine internal safety errors (#5080) + +### Integrations + +- Added documentation for doctest formatting tools and updated the integrations index to + match (#4916) + +### Documentation + +- Use "Version X.Y.Z" headings in changelog for stable permalink anchors on ReadTheDocs + (#5063) +- Note in the editor integrations that the SublimeText `sublack` plugin is archived and + unmaintained (#5082) + +## Version 26.3.1 + +### Stable style + +- Prevent Jupyter notebook magic masking collisions from corrupting cells by using + exact-length placeholders for short magics and aborting if a placeholder can no longer + be unmasked safely (#5038) + +### Configuration + +- Always hash cache filename components derived from `--python-cell-magics` so custom + magic names cannot affect cache paths (#5038) + +### _Blackd_ + +- Disable browser-originated requests by default, add configurable origin allowlisting + and request body limits, and bound executor submissions to improve backpressure + (#5039) + +## Version 26.3.0 + +### Stable style + +- Don't double-decode input, causing non-UTF-8 files to be corrupted (#4964) +- Fix crash on standalone comment in lambda default arguments (#4993) +- Preserve parentheses when `# type: ignore` comments would be merged with other + comments on the same line, preventing AST equivalence failures (#4888) + +### Preview style + +- Fix bug where `if` guards in `case` blocks were incorrectly split when the pattern had + a trailing comma (#4884) +- Fix `string_processing` crashing on unassigned long string literals with trailing + commas (one-item tuples) (#4929) +- Simplify implementation of the power operator "hugging" logic (#4918) + +### Packaging + +- Fix shutdown errors in PyInstaller builds on macOS by disabling multiprocessing in + frozen environments (#4930) + +### Performance + +- Introduce winloop for windows as an alternative to uvloop (#4996) +- Remove deprecated function `uvloop.install()` in favor of `uvloop.new_event_loop()` + (#4996) +- Rename `maybe_install_uvloop` function to `maybe_use_uvloop` to simplify loop + installation and creation of either a uvloop/winloop eventloop or default eventloop + (#4996) + +### Output + +- Emit a clear warning when the target Python version is newer than the running Python + version, since AST safety checks cannot parse newer syntax. Also replace the + misleading "INTERNAL ERROR" message with an actionable error explaining the version + mismatch (#4983) + +### _Blackd_ + +- Introduce winloop to be used when windows in use which enables blackd to run faster on + windows when winloop is installed. (#4996) + +### Integrations + +- Remove unused gallery script (#5030) +- Harden parsing of `black` requirements in the GitHub Action when `use_pyproject` is + enabled so that only version specifiers are accepted and direct references such as + `black @ https://...` are rejected. Users should upgrade to the latest version of the + action as soon as possible. This update is received automatically when using + `psf/black@stable`, and is independent of the version of Black installed by the + action. (#5031) + +### Documentation + +- Expand preview style documentation with detailed examples for `wrap_comprehension_in`, + `simplify_power_operator_hugging`, and `wrap_long_dict_values_in_parens` features + (#4987) +- Add detailed documentation for formatting Jupyter Notebooks (#5009) + +## Version 26.1.0 + +### Highlights + +Introduces the 2026 stable style (#4892), stabilizing the following changes: + +- `always_one_newline_after_import`: Always force one blank line after import + statements, except when the line after the import is a comment or an import statement + (#4489) +- `fix_fmt_skip_in_one_liners`: Fix `# fmt: skip` behavior on one-liner declarations, + such as `def foo(): return "mock" # fmt: skip`, where previously the declaration would + have been incorrectly collapsed (#4800) +- `fix_module_docstring_detection`: Fix module docstrings being treated as normal + strings if preceded by comments (#4764) +- `fix_type_expansion_split`: Fix type expansions split in generic functions (#4777) +- `multiline_string_handling`: Make expressions involving multiline strings more compact + (#1879) +- `normalize_cr_newlines`: Add `\r` style newlines to the potential newlines to + normalize file newlines both from and to (#4710) +- `remove_parens_around_except_types`: Remove parentheses around multiple exception + types in `except` and `except*` without `as` (#4720) +- `remove_parens_from_assignment_lhs`: Remove unnecessary parentheses from the left-hand + side of assignments while preserving magic trailing commas and intentional multiline + formatting (#4865) +- `standardize_type_comments`: Format type comments which have zero or more spaces + between `#` and `type:` or between `type:` and value to `# type: (value)` (#4645) + +The following change was not in any previous stable release: + +- Regenerated the `_width_table.py` and added tests for the Khmer language (#4253) + +This release alo bumps `pathspec` to v1 and fixes inconsistencies with Git's +`.gitignore` logic (#4958). Now, files will be ignored if a pattern matches them, even +if the parent directory is directly unignored. For example, Black would previously +format `exclude/not_this/foo.py` with this `.gitignore`: + +``` +exclude/ +!exclude/not_this/ +``` + +Now, `exclude/not_this/foo.py` will remain ignored. To ensure `exclude/not_this/` and +all of it's children are included in formatting (and in Git), use this `.gitignore`: + +``` +*/exclude/* +!*/exclude/not_this/ +``` + +This new behavior matches Git. The leading `*/` are only necessary if you wish to ignore +matching subdirectories (like the previous behavior did), and not just matching root +directories. + +### Output + +- Explicitly shutdown the multiprocessing manager when run in diff mode too (#4952) + +### Integrations + +- Upgraded PyPI upload workflow to use Trusted Publishing (#4611) + +## Version 25.12.0 + +### Highlights + +- Black no longer supports running with Python 3.9 (#4842) + +### Stable style + +- Fix bug where comments preceding `# fmt: off`/`# fmt: on` blocks were incorrectly + removed, particularly affecting Jupytext's `# %% [markdown]` comments (#4845) +- Fix crash when multiple `# fmt: skip` comments are used in a multi-part if-clause, on + string literals, or on dictionary entries with long lines (#4872) +- Fix possible crash when `fmt: ` directives aren't on the top level (#4856) + +### Preview style + +- Fix `fmt: skip` skipping the line after instead of the line it's on (#4855) +- Remove unnecessary parentheses from the left-hand side of assignments while preserving + magic trailing commas and intentional multiline formatting (#4865) +- Fix `fix_fmt_skip_in_one_liners` crashing on `with` statements (#4853) +- Fix `fix_fmt_skip_in_one_liners` crashing on annotated parameters (#4854) +- Fix new lines being added after imports with `# fmt: skip` on them (#4894) + +### Packaging + +- Releases now include arm64 Windows binaries and wheels (#4814) + +### Integrations + +- Add `output-file` input to GitHub Action `psf/black` to write formatter output to a + file for artifact capture and log cleanliness (#4824) + +## Version 25.11.0 + +### Highlights + +- Enable base 3.14 support (#4804) +- Add support for the new Python 3.14 t-string syntax introduced by PEP 750 (#4805) + +### Stable style + +- Fix bug where comments between `# fmt: off` and `# fmt: on` were reformatted (#4811) +- Comments containing fmt directives now preserve their exact formatting instead of + being normalized (#4811) + +### Preview style + +- Move `multiline_string_handling` from `--unstable` to `--preview` (#4760) +- Fix bug where module docstrings would be treated as normal strings if preceded by + comments (#4764) +- Fix bug where python 3.12 generics syntax split line happens weirdly (#4777) +- Standardize type comments to form `# type: ` (#4645) +- Fix `fix_fmt_skip_in_one_liners` preview feature to respect `# fmt: skip` for compound + statements with semicolon-separated bodies (#4800) + +### Configuration + +- Add `no_cache` option to control caching behavior. (#4803) + +### Packaging + +- Releases now include arm64 Linux binaries (#4773) + +### Output + +- Write unchanged content to stdout when excluding formatting from stdin using pipes + (#4610) + +### _Blackd_ + +- Implemented BlackDClient. This simple python client allows to easily send formatting + requests to blackd (#4774) + +### Integrations + +- Enable 3.14 base CI (#4804) +- Enhance GitHub Action `psf/black` to support the `required-version` major-version-only + "stability" format when using pyproject.toml (#4770) +- Improve error message for vim plugin users. It now handles independently vim version +- Vim: Warn on unsupported Vim and Python versions independently (#4772) +- Vim: Print the import paths when importing black fails (#4675) +- Vim: Fix handling of virtualenvs that have a different Python version (#4675) + +## Version 25.9.0 + +### Highlights + +- Remove support for pre-python 3.7 `await/async` as soft keywords/variable names + (#4676) + +### Stable style + +- Fix crash while formatting a long `del` statement containing tuples (#4628) +- Fix crash while formatting expressions using the walrus operator in complex `with` + statements (#4630) +- Handle `# fmt: skip` followed by a comment at the end of file (#4635) +- Fix crash when a tuple appears in the `as` clause of a `with` statement (#4634) +- Fix crash when tuple is used as a context manager inside a `with` statement (#4646) +- Fix crash when formatting a `\` followed by a `\r` followed by a comment (#4663) +- Fix crash on a `\\r\n` (#4673) +- Fix crash on `await ...` (where `...` is a literal `Ellipsis`) (#4676) +- Fix crash on parenthesized expression inside a type parameter bound (#4684) +- Fix crash when using line ranges excluding indented single line decorated items + (#4670) + +### Preview style + +- Fix a bug where one-liner functions/conditionals marked with `# fmt: skip` would still + be formatted (#4552) +- Improve `multiline_string_handling` with ternaries and dictionaries (#4657) +- Fix a bug where `string_processing` would not split f-strings directly after + expressions (#4680) +- Wrap the `in` clause of comprehensions across lines if necessary (#4699) +- Remove parentheses around multiple exception types in `except` and `except*` without + `as`. (#4720) +- Add `\r` style newlines to the potential newlines to normalize file newlines both from + and to (#4710) + +### Parser + +- Rewrite tokenizer to improve performance and compliance (#4536) +- Fix bug where certain unusual expressions (e.g., lambdas) were not accepted in type + parameter bounds and defaults. (#4602) + +### Performance + +- Avoid using an extra process when running with only one worker (#4734) + +### Integrations + +- Fix the version check in the vim file to reject Python 3.8 (#4567) +- Enhance GitHub Action `psf/black` to read Black version from an additional section in + pyproject.toml: `[project.dependency-groups]` (#4606) +- Build gallery docker image with python3-slim and reduce image size (#4686) + +### Documentation + +- Add FAQ entry for windows emoji not displaying (#4714) + +## Version 25.1.0 + +### Highlights + +This release introduces the new 2025 stable style (#4558), stabilizing the following +changes: + +- Normalize casing of Unicode escape characters in strings to lowercase (#2916) +- Fix inconsistencies in whether certain strings are detected as docstrings (#4095) +- Consistently add trailing commas to typed function parameters (#4164) +- Remove redundant parentheses in if guards for case blocks (#4214) +- Add parentheses to if clauses in case blocks when the line is too long (#4269) +- Whitespace before `# fmt: skip` comments is no longer normalized (#4146) +- Fix line length computation for certain expressions that involve the power operator + (#4154) +- Check if there is a newline before the terminating quotes of a docstring (#4185) +- Fix type annotation spacing between `*` and more complex type variable tuple (#4440) + +The following changes were not in any previous release: + +- Remove parentheses around sole list items (#4312) +- Generic function definitions are now formatted more elegantly: parameters are split + over multiple lines first instead of type parameter definitions (#4553) + +### Stable style + +- Fix formatting cells in IPython notebooks with magic methods and starting or trailing + empty lines (#4484) +- Fix crash when formatting `with` statements containing tuple generators/unpacking + (#4538) + +### Preview style + +- Fix/remove string merging changing f-string quotes on f-strings with internal quotes + (#4498) +- Collapse multiple empty lines after an import into one (#4489) +- Prevent `string_processing` and `wrap_long_dict_values_in_parens` from removing + parentheses around long dictionary values (#4377) +- Move `wrap_long_dict_values_in_parens` from the unstable to preview style (#4561) + +### Packaging + +- Store license identifier inside the `License-Expression` metadata field, see + [PEP 639](https://peps.python.org/pep-0639/). (#4479) + +### Performance + +- Speed up the `is_fstring_start` function in Black's tokenizer (#4541) + +### Integrations + +- If using stdin with `--stdin-filename` set to a force excluded path, stdin won't be + formatted. (#4539) + +## Version 24.10.0 + +### Highlights + +- Black is now officially tested with Python 3.13 and provides Python 3.13 + mypyc-compiled wheels. (#4436) (#4449) +- Black will issue an error when used with Python 3.12.5, due to an upstream memory + safety issue in Python 3.12.5 that can cause Black's AST safety checks to fail. Please + use Python 3.12.6 or Python 3.12.4 instead. (#4447) +- Black no longer supports running with Python 3.8 (#4452) + +### Stable style + +- Fix crashes involving comments in parenthesised return types or `X | Y` style unions. + (#4453) +- Fix skipping Jupyter cells with unknown `%%` magic (#4462) + +### Preview style + +- Fix type annotation spacing between * and more complex type variable tuple (i.e. `def + fn(*args: *tuple[*Ts, T]) -> None: pass`) (#4440) + +### Caching + +- Fix bug where the cache was shared between runs with and without `--unstable` (#4466) + +### Packaging + +- Upgrade version of mypyc used to 1.12 beta (#4450) (#4449) +- `blackd` now requires a newer version of aiohttp. (#4451) + +### Output + +- Added Python target version information on parse error (#4378) +- Add information about Black version to internal error messages (#4457) + +## Version 24.8.0 + +### Stable style + +- Fix crash when `# fmt: off` is used before a closing parenthesis or bracket. (#4363) + +### Packaging + +- Packaging metadata updated: docs are explicitly linked, the issue tracker is now also + linked. This improves the PyPI listing for Black. (#4345) + +### Parser + +- Fix regression where Black failed to parse a multiline f-string containing another + multiline string (#4339) +- Fix regression where Black failed to parse an escaped single quote inside an f-string + (#4401) +- Fix bug with Black incorrectly parsing empty lines with a backslash (#4343) +- Fix bugs with Black's tokenizer not handling `\{` inside f-strings very well (#4422) +- Fix incorrect line numbers in the tokenizer for certain tokens within f-strings + (#4423) + +### Performance + +- Improve performance when a large directory is listed in `.gitignore` (#4415) + +### _Blackd_ + +- Fix blackd (and all extras installs) for docker container (#4357) + +## Version 24.4.2 + +This is a bugfix release to fix two regressions in the new f-string parser introduced in +24.4.1. + +### Parser + +- Fix regression where certain complex f-strings failed to parse (#4332) + +### Performance + +- Fix bad performance on certain complex string literals (#4331) + +## Version 24.4.1 + +### Highlights + +- Add support for the new Python 3.12 f-string syntax introduced by PEP 701 (#3822) + +### Stable style + +- Fix crash involving indented dummy functions containing newlines (#4318) + +### Parser + +- Add support for type parameter defaults, a new syntactic feature added to Python 3.13 + by PEP 696 (#4327) + +### Integrations + +- Github Action now works even when `git archive` is skipped (#4313) + +## Version 24.4.0 + +### Stable style + +- Fix unwanted crashes caused by AST equivalency check (#4290) + +### Preview style + +- `if` guards in `case` blocks are now wrapped in parentheses when the line is too long. + (#4269) +- Stop moving multiline strings to a new line unless inside brackets (#4289) + +### Integrations + +- Add a new option `use_pyproject` to the GitHub Action `psf/black`. This will read the + Black version from `pyproject.toml`. (#4294) + +## Version 24.3.0 + +### Highlights + +This release is a milestone: it fixes Black's first CVE security vulnerability. If you +run Black on untrusted input, or if you habitually put thousands of leading tab +characters in your docstrings, you are strongly encouraged to upgrade immediately to fix +[CVE-2024-21503](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2024-21503). + +This release also fixes a bug in Black's AST safety check that allowed Black to make +incorrect changes to certain f-strings that are valid in Python 3.12 and higher. + +### Stable style + +- Don't move comments along with delimiters, which could cause crashes (#4248) +- Strengthen AST safety check to catch more unsafe changes to strings. Previous versions + of Black would incorrectly format the contents of certain unusual f-strings containing + nested strings with the same quote type. Now, Black will crash on such strings until + support for the new f-string syntax is implemented. (#4270) +- Fix a bug where line-ranges exceeding the last code line would not work as expected + (#4273) + +### Performance + +- Fix catastrophic performance on docstrings that contain large numbers of leading tab + characters. This fixes + [CVE-2024-21503](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2024-21503). + (#4278) + +### Documentation + +- Note what happens when `--check` is used with `--quiet` (#4236) + +## Version 24.2.0 + +### Stable style + +- Fixed a bug where comments where mistakenly removed along with redundant parentheses + (#4218) + +### Preview style + +- Move the `hug_parens_with_braces_and_square_brackets` feature to the unstable style + due to an outstanding crash and proposed formatting tweaks (#4198) +- Fixed a bug where base expressions caused inconsistent formatting of \*\* in ternary + expression (#4154) +- Checking for newline before adding one on docstring that is almost at the line limit + (#4185) +- Remove redundant parentheses in `case` statement `if` guards (#4214). + +### Configuration + +- Fix issue where _Black_ would ignore input files in the presence of symlinks (#4222) +- _Black_ now ignores `pyproject.toml` that is missing a `tool.black` section when + discovering project root and configuration. Since _Black_ continues to use version + control as an indicator of project root, this is expected to primarily change behavior + for users in a monorepo setup (desirably). If you wish to preserve previous behavior, + simply add an empty `[tool.black]` to the previously discovered `pyproject.toml` + (#4204) + +### Output + +- Black will swallow any `SyntaxWarning`s or `DeprecationWarning`s produced by the `ast` + module when performing equivalence checks (#4189) + +### Integrations + +- Add a JSONSchema and provide a validate-pyproject entry-point (#4181) + +## Version 24.1.1 + +Bugfix release to fix a bug that made Black unusable on certain file systems with strict +limits on path length. + +### Preview style + +- Consistently add trailing comma on typed parameters (#4164) + +### Configuration + +- Shorten the length of the name of the cache file to fix crashes on file systems that + do not support long paths (#4176) + +## Version 24.1.0 + +### Highlights + +This release introduces the new 2024 stable style (#4106), stabilizing the following +changes: + +- Add parentheses around `if`-`else` expressions (#2278) +- Dummy class and function implementations consisting only of `...` are formatted more + compactly (#3796) +- If an assignment statement is too long, we now prefer splitting on the right-hand side + (#3368) +- Hex codes in Unicode escape sequences are now standardized to lowercase (#2916) +- Allow empty first lines at the beginning of most blocks (#3967, #4061) +- Add parentheses around long type annotations (#3899) +- Enforce newline after module docstrings (#3932, #4028) +- Fix incorrect magic trailing comma handling in return types (#3916) +- Remove blank lines before class docstrings (#3692) +- Wrap multiple context managers in parentheses if combined in a single `with` statement + (#3489) +- Fix bug in line length calculations for power operations (#3942) +- Add trailing commas to collection literals even if there's a comment after the last + entry (#3393) +- When using `--skip-magic-trailing-comma` or `-C`, trailing commas are stripped from + subscript expressions with more than 1 element (#3209) +- Add extra blank lines in stubs in a few cases (#3564, #3862) +- Accept raw strings as docstrings (#3947) +- Split long lines in case blocks (#4024) +- Stop removing spaces from walrus operators within subscripts (#3823) +- Fix incorrect formatting of certain async statements (#3609) +- Allow combining `# fmt: skip` with other comments (#3959) + +There are already a few improvements in the `--preview` style, which are slated for the +2025 stable style. Try them out and +[share your feedback](https://github.com/psf/black/issues). In the past, the preview +style has included some features that we were not able to stabilize. This year, we're +adding a separate `--unstable` style for features with known problems. Now, the +`--preview` style only includes features that we actually expect to make it into next +year's stable style. + +### Stable style + +Several bug fixes were made in features that are moved to the stable style in this +release: + +- Fix comment handling when parenthesising conditional expressions (#4134) +- Fix bug where spaces were not added around parenthesized walruses in subscripts, + unlike other binary operators (#4109) +- Remove empty lines before docstrings in async functions (#4132) +- Address a missing case in the change to allow empty lines at the beginning of all + blocks, except immediately before a docstring (#4130) +- For stubs, fix logic to enforce empty line after nested classes with bodies (#4141) + +### Preview style + +- Add `--unstable` style, covering preview features that have known problems that would + block them from going into the stable style. Also add the `--enable-unstable-feature` + flag; for example, use + `--enable-unstable-feature hug_parens_with_braces_and_square_brackets` to apply this + preview feature throughout 2024, even if a later Black release downgrades the feature + to unstable (#4096) +- Format module docstrings the same as class and function docstrings (#4095) +- Fix crash when using a walrus in a dictionary (#4155) +- Fix unnecessary parentheses when wrapping long dicts (#4135) +- Stop normalizing spaces before `# fmt: skip` comments (#4146) + +### Configuration + +- Print warning when configuration in `pyproject.toml` contains an invalid key (#4165) +- Fix symlink handling, properly ignoring symlinks that point outside of root (#4161) +- Fix cache mtime logic that resulted in false positive cache hits (#4128) +- Remove the long-deprecated `--experimental-string-processing` flag. This feature can + currently be enabled with `--preview --enable-unstable-feature string_processing`. + (#4096) + +### Integrations + +- Revert the change to run Black's pre-commit integration only on specific git hooks + (#3940) for better compatibility with older versions of pre-commit (#4137) + +## Version 23.12.1 + +### Packaging + +- Fixed a bug that included dependencies from the `d` extra by default (#4108) + +## Version 23.12.0 + +### Highlights + +It's almost 2024, which means it's time for a new edition of _Black_'s stable style! +Together with this release, we'll put out an alpha release 24.1a1 showcasing the draft +2024 stable style, which we'll finalize in the January release. Please try it out and +[share your feedback](https://github.com/psf/black/issues/4042). + +This release (23.12.0) will still produce the 2023 style. Most but not all of the +changes in `--preview` mode will be in the 2024 stable style. + +### Stable style + +- Fix bug where `# fmt: off` automatically dedents when used with the `--line-ranges` + option, even when it is not within the specified line range. (#4084) +- Fix feature detection for parenthesized context managers (#4104) + +### Preview style + +- Prefer more equal signs before a break when splitting chained assignments (#4010) +- Standalone form feed characters at the module level are no longer removed (#4021) +- Additional cases of immediately nested tuples, lists, and dictionaries are now + indented less (#4012) +- Allow empty lines at the beginning of all blocks, except immediately before a + docstring (#4060) +- Fix crash in preview mode when using a short `--line-length` (#4086) +- Keep suites consisting of only an ellipsis on their own lines if they are not + functions or class definitions (#4066) (#4103) + +### Configuration + +- `--line-ranges` now skips _Black_'s internal stability check in `--safe` mode. This + avoids a crash on rare inputs that have many unformatted same-content lines. (#4034) + +### Packaging + +- Upgrade to mypy 1.7.1 (#4049) (#4069) +- Faster compiled wheels are now available for CPython 3.12 (#4070) + +### Integrations + +- Enable 3.12 CI (#4035) +- Build docker images in parallel (#4054) +- Build docker images with 3.12 (#4055) + +## Version 23.11.0 + +### Highlights + +- Support formatting ranges of lines with the new `--line-ranges` command-line option + (#4020) + +### Stable style + +- Fix crash on formatting bytes strings that look like docstrings (#4003) +- Fix crash when whitespace followed a backslash before newline in a docstring (#4008) +- Fix standalone comments inside complex blocks crashing Black (#4016) +- Fix crash on formatting code like `await (a ** b)` (#3994) +- No longer treat leading f-strings as docstrings. This matches Python's behaviour and + fixes a crash (#4019) + +### Preview style + +- Multiline dicts and lists that are the sole argument to a function are now indented + less (#3964) +- Multiline unpacked dicts and lists as the sole argument to a function are now also + indented less (#3992) +- In f-string debug expressions, quote types that are visible in the final string are + now preserved (#4005) +- Fix a bug where long `case` blocks were not split into multiple lines. Also enable + general trailing comma rules on `case` blocks (#4024) +- Keep requiring two empty lines between module-level docstring and first function or + class definition (#4028) +- Add support for single-line format skip with other comments on the same line (#3959) + +### Configuration + +- Consistently apply force exclusion logic before resolving symlinks (#4015) +- Fix a bug in the matching of absolute path names in `--include` (#3976) + +### Performance + +- Fix mypyc builds on arm64 on macOS (#4017) + +### Integrations + +- Black's pre-commit integration will now run only on git hooks appropriate for a code + formatter (#3940) + +## Version 23.10.1 + +### Highlights + +- Maintenance release to get a fix out for GitHub Action edge case (#3957) + +### Preview style + +- Fix merging implicit multiline strings that have inline comments (#3956) +- Allow empty first line after block open before a comment or compound statement (#3967) + +### Packaging + +- Change Dockerfile to hatch + compile black (#3965) + +### Integrations + +- The summary output for GitHub workflows is now suppressible using the `summary` + parameter. (#3958) +- Fix the action failing when Black check doesn't pass (#3957) + +### Documentation + +- It is known Windows documentation CI is broken + https://github.com/psf/black/issues/3968 + +## Version 23.10.0 + +### Stable style + +- Fix comments getting removed from inside parenthesized strings (#3909) + +### Preview style + +- Fix long lines with power operators getting split before the line length (#3942) +- Long type hints are now wrapped in parentheses and properly indented when split across + multiple lines (#3899) +- Magic trailing commas are now respected in return types. (#3916) +- Require one empty line after module-level docstrings. (#3932) +- Treat raw triple-quoted strings as docstrings (#3947) + +### Configuration + +- Fix cache versioning logic when `BLACK_CACHE_DIR` is set (#3937) + +### Parser + +- Fix bug where attributes named `type` were not accepted inside `match` statements + (#3950) +- Add support for PEP 695 type aliases containing lambdas and other unusual expressions + (#3949) + +### Output + +- Black no longer attempts to provide special errors for attempting to format Python 2 + code (#3933) +- Black will more consistently print stacktraces on internal errors in verbose mode + (#3938) + +### Integrations + +- The action output displayed in the job summary is now wrapped in Markdown (#3914) + +## Version 23.9.1 + +Due to various issues, the previous release (23.9.0) did not include compiled mypyc +wheels, which make Black significantly faster. These issues have now been fixed, and +this release should come with compiled wheels once again. + +There will be no wheels for Python 3.12 due to a bug in mypyc. We will provide 3.12 +wheels in a future release as soon as the mypyc bug is fixed. + +### Packaging + +- Upgrade to mypy 1.5.1 (#3864) + +### Performance + +- Store raw tuples instead of NamedTuples in Black's cache, improving performance and + decreasing the size of the cache (#3877) + +## Version 23.9.0 + +### Preview style + +- More concise formatting for dummy implementations (#3796) +- In stub files, add a blank line between a statement with a body (e.g an + `if sys.version_info > (3, x):`) and a function definition on the same level (#3862) +- Fix a bug whereby spaces were removed from walrus operators within subscript(#3823) + +### Configuration + +- Black now applies exclusion and ignore logic before resolving symlinks (#3846) + +### Performance + +- Avoid importing `IPython` if notebook cells do not contain magics (#3782) +- Improve caching by comparing file hashes as fallback for mtime and size (#3821) + +### _Blackd_ + +- Fix an issue in `blackd` with single character input (#3558) + +### Integrations + +- Black now has an + [official pre-commit mirror](https://github.com/psf/black-pre-commit-mirror). Swapping + `https://github.com/psf/black` to `https://github.com/psf/black-pre-commit-mirror` in + your `.pre-commit-config.yaml` will make Black about 2x faster (#3828) +- The `.black.env` folder specified by `ENV_PATH` will now be removed on the completion + of the GitHub Action (#3759) + +## Version 23.7.0 + +### Highlights + +- Runtime support for Python 3.7 has been removed. Formatting 3.7 code will still be + supported until further notice (#3765) + +### Stable style + +- Fix a bug where an illegal trailing comma was added to return type annotations using + PEP 604 unions (#3735) +- Fix several bugs and crashes where comments in stub files were removed or mishandled + under some circumstances (#3745) +- Fix a crash with multi-line magic comments like `type: ignore` within parentheses + (#3740) +- Fix error in AST validation when _Black_ removes trailing whitespace in a type comment + (#3773) + +### Preview style + +- Implicitly concatenated strings used as function args are no longer wrapped inside + parentheses (#3640) +- Remove blank lines between a class definition and its docstring (#3692) + +### Configuration + +- The `--workers` argument to _Black_ can now be specified via the `BLACK_NUM_WORKERS` + environment variable (#3743) +- `.pytest_cache`, `.ruff_cache` and `.vscode` are now excluded by default (#3691) +- Fix _Black_ not honouring `pyproject.toml` settings when running `--stdin-filename` + and the `pyproject.toml` found isn't in the current working directory (#3719) +- _Black_ will now error if `exclude` and `extend-exclude` have invalid data types in + `pyproject.toml`, instead of silently doing the wrong thing (#3764) + +### Packaging + +- Upgrade mypyc from 0.991 to 1.3 (#3697) +- Remove patching of Click that mitigated errors on Python 3.6 with `LANG=C` (#3768) + +### Parser + +- Add support for the new PEP 695 syntax in Python 3.12 (#3703) + +### Performance + +- Speed up _Black_ significantly when the cache is full (#3751) +- Avoid importing `IPython` in a case where we wouldn't need it (#3748) + +### Output + +- Use aware UTC datetimes internally, avoids deprecation warning on Python 3.12 (#3728) +- Change verbose logging to exactly mirror _Black_'s logic for source discovery (#3749) + +### _Blackd_ + +- The `blackd` argument parser now shows the default values for options in their help + text (#3712) + +### Integrations + +- Black is now tested with + [`PYTHONWARNDEFAULTENCODING = 1`](https://docs.python.org/3/library/io.html#io-encoding-warning) + (#3763) +- Update GitHub Action to display black output in the job summary (#3688) + +### Documentation + +- Add a CITATION.cff file to the root of the repository, containing metadata on how to + cite this software (#3723) +- Update the _classes_ and _exceptions_ documentation in Developer reference to match + the latest code base (#3755) + +## Version 23.3.0 + +### Highlights + +This release fixes a longstanding confusing behavior in Black's GitHub action, where the +version of the action did not determine the version of Black being run (issue #3382). In +addition, there is a small bug fix around imports and a number of improvements to the +preview style. + +Please try out the +[preview style](https://black.readthedocs.io/en/stable/the_black_code_style/future_style.html#preview-style) +with `black --preview` and tell us your feedback. All changes in the preview style are +expected to become part of Black's stable style in January 2024. + +### Stable style + +- Import lines with `# fmt: skip` and `# fmt: off` no longer have an extra blank line + added when they are right after another import line (#3610) + +### Preview style + +- Add trailing commas to collection literals even if there's a comment after the last + entry (#3393) +- `async def`, `async for`, and `async with` statements are now formatted consistently + compared to their non-async version. (#3609) +- `with` statements that contain two context managers will be consistently wrapped in + parentheses (#3589) +- Let string splitters respect [East Asian Width](https://www.unicode.org/reports/tr11/) + (#3445) +- Now long string literals can be split after East Asian commas and periods (`、` U+3001 + IDEOGRAPHIC COMMA, `。` U+3002 IDEOGRAPHIC FULL STOP, & `，` U+FF0C FULLWIDTH COMMA) + besides before spaces (#3445) +- For stubs, enforce one blank line after a nested class with a body other than just + `...` (#3564) +- Improve handling of multiline strings by changing line split behavior (#1879) + +### Parser + +- Added support for formatting files with invalid type comments (#3594) + +### Integrations + +- Update GitHub Action to use the version of Black equivalent to action's version if + version input is not specified (#3543) +- Fix missing Python binary path in autoload script for vim (#3508) + +### Documentation + +- Document that only the most recent release is supported for security issues; + vulnerabilities should be reported through Tidelift (#3612) + +## Version 23.1.0 + +### Highlights + +This is the first release of 2023, and following our +[stability policy](https://black.readthedocs.io/en/stable/the_black_code_style/index.html#stability-policy), +it comes with a number of improvements to our stable style, including improvements to +empty line handling, removal of redundant parentheses in several contexts, and output +that highlights implicitly concatenated strings better. + +There are also many changes to the preview style; try out `black --preview` and give us +feedback to help us set the stable style for next year. + +In addition to style changes, Black now automatically infers the supported Python +versions from your `pyproject.toml` file, removing the need to set Black's target +versions separately. + +### Stable style + +- Introduce the 2023 stable style, which incorporates most aspects of last year's + preview style (#3418). Specific changes: + - Enforce empty lines before classes and functions with sticky leading comments + (#3302) (22.12.0) + - Reformat empty and whitespace-only files as either an empty file (if no newline is + present) or as a single newline character (if a newline is present) (#3348) + (22.12.0) + - Implicitly concatenated strings used as function args are now wrapped inside + parentheses (#3307) (22.12.0) + - Correctly handle trailing commas that are inside a line's leading non-nested parens + (#3370) (22.12.0) + - `--skip-string-normalization` / `-S` now prevents docstring prefixes from being + normalized as expected (#3168) (since 22.8.0) + - When using `--skip-magic-trailing-comma` or `-C`, trailing commas are stripped from + subscript expressions with more than 1 element (#3209) (22.8.0) + - Implicitly concatenated strings inside a list, set, or tuple are now wrapped inside + parentheses (#3162) (22.8.0) + - Fix a string merging/split issue when a comment is present in the middle of + implicitly concatenated strings on its own line (#3227) (22.8.0) + - Docstring quotes are no longer moved if it would violate the line length limit + (#3044, #3430) (22.6.0) + - Parentheses around return annotations are now managed (#2990) (22.6.0) + - Remove unnecessary parentheses around awaited objects (#2991) (22.6.0) + - Remove unnecessary parentheses in `with` statements (#2926) (22.6.0) + - Remove trailing newlines after code block open (#3035) (22.6.0) + - Code cell separators `#%%` are now standardised to `# %%` (#2919) (22.3.0) + - Remove unnecessary parentheses from `except` statements (#2939) (22.3.0) + - Remove unnecessary parentheses from tuple unpacking in `for` loops (#2945) (22.3.0) + - Avoid magic-trailing-comma in single-element subscripts (#2942) (22.3.0) +- Fix a crash when a colon line is marked between `# fmt: off` and `# fmt: on` (#3439) + +### Preview style + +- Format hex codes in unicode escape sequences in string literals (#2916) +- Add parentheses around `if`-`else` expressions (#2278) +- Improve performance on large expressions that contain many strings (#3467) +- Fix a crash in preview style with assert + parenthesized string (#3415) +- Fix crashes in preview style with walrus operators used in function return annotations + and except clauses (#3423) +- Fix a crash in preview advanced string processing where mixed implicitly concatenated + regular and f-strings start with an empty span (#3463) +- Fix a crash in preview advanced string processing where a standalone comment is placed + before a dict's value (#3469) +- Fix an issue where extra empty lines are added when a decorator has `# fmt: skip` + applied or there is a standalone comment between decorators (#3470) +- Do not put the closing quotes in a docstring on a separate line, even if the line is + too long (#3430) +- Long values in dict literals are now wrapped in parentheses; correspondingly + unnecessary parentheses around short values in dict literals are now removed; long + string lambda values are now wrapped in parentheses (#3440) +- Fix two crashes in preview style involving edge cases with docstrings (#3451) +- Exclude string type annotations from improved string processing; fix crash when the + return type annotation is stringified and spans across multiple lines (#3462) +- Wrap multiple context managers in parentheses when targeting Python 3.9+ (#3489) +- Fix several crashes in preview style with walrus operators used in `with` statements + or tuples (#3473) +- Fix an invalid quote escaping bug in f-string expressions where it produced invalid + code. Implicitly concatenated f-strings with different quotes can now be merged or + quote-normalized by changing the quotes used in expressions. (#3509) +- Fix crash on `await (yield)` when Black is compiled with mypyc (#3533) + +### Configuration + +- Black now tries to infer its `--target-version` from the project metadata specified in + `pyproject.toml` (#3219) + +### Packaging + +- Upgrade mypyc from `0.971` to `0.991` so mypycified _Black_ can be built on armv7 + (#3380) + - This also fixes some crashes while using compiled Black with a debug build of + CPython +- Drop specific support for the `tomli` requirement on 3.11 alpha releases, working + around a bug that would cause the requirement not to be installed on any non-final + Python releases (#3448) +- Black now depends on `packaging` version `22.0` or later. This is required for new + functionality that needs to parse part of the project metadata (#3219) + +### Output + +- Calling `black --help` multiple times will return the same help contents each time + (#3516) +- Verbose logging now shows the values of `pyproject.toml` configuration variables + (#3392) +- Fix false symlink detection messages in verbose output due to using an incorrect + relative path to the project root (#3385) + +### Integrations + +- Move 3.11 CI to normal flow now that all dependencies support 3.11 (#3446) +- Docker: Add new `latest_prerelease` tag automation to follow latest black alpha + release on docker images (#3465) + +### Documentation + +- Expand `vim-plug` installation instructions to offer more explicit options (#3468) + +## Version 22.12.0 + +### Preview style + +- Enforce empty lines before classes and functions with sticky leading comments (#3302) +- Reformat empty and whitespace-only files as either an empty file (if no newline is + present) or as a single newline character (if a newline is present) (#3348) +- Implicitly concatenated strings used as function args are now wrapped inside + parentheses (#3307) +- For assignment statements, prefer splitting the right hand side if the left hand side + fits on a single line (#3368) +- Correctly handle trailing commas that are inside a line's leading non-nested parens + (#3370) + +### Configuration + +- Fix incorrectly applied `.gitignore` rules by considering the `.gitignore` location + and the relative path to the target file (#3338) +- Fix incorrectly ignoring `.gitignore` presence when more than one source directory is + specified (#3336) + +### Parser + +- Parsing support has been added for walruses inside generator expression that are + passed as function args (for example, + `any(match := my_re.match(text) for text in texts)`) (#3327). + +### Integrations + +- Vim plugin: Optionally allow using the system installation of Black via + `let g:black_use_virtualenv = 0`(#3309) + +## Version 22.10.0 + +### Highlights + +- Runtime support for Python 3.6 has been removed. Formatting 3.6 code will still be + supported until further notice. + +### Stable style + +- Fix a crash when `# fmt: on` is used on a different block level than `# fmt: off` + (#3281) + +### Preview style + +- Fix a crash when formatting some dicts with parenthesis-wrapped long string keys + (#3262) + +### Configuration + +- `.ipynb_checkpoints` directories are now excluded by default (#3293) +- Add `--skip-source-first-line` / `-x` option to ignore the first line of source code + while formatting (#3299) + +### Packaging + +- Executables made with PyInstaller will no longer crash when formatting several files + at once on macOS. Native x86-64 executables for macOS are available once again. + (#3275) +- Hatchling is now used as the build backend. This will not have any effect for users + who install Black with its wheels from PyPI. (#3233) +- Faster compiled wheels are now available for CPython 3.11 (#3276) + +### _Blackd_ + +- Windows style (CRLF) newlines will be preserved (#3257). + +### Integrations + +- Vim plugin: add flag (`g:black_preview`) to enable/disable the preview style (#3246) +- Update GitHub Action to support formatting of Jupyter Notebook files via a `jupyter` + option (#3282) +- Update GitHub Action to support use of version specifiers (e.g. `<23`) for Black + version (#3265) + +## Version 22.8.0 + +### Highlights + +- Python 3.11 is now supported, except for _blackd_ as aiohttp does not support 3.11 as + of publishing (#3234) +- This is the last release that supports running _Black_ on Python 3.6 (formatting 3.6 + code will continue to be supported until further notice) +- Reword the stability policy to say that we may, in rare cases, make changes that + affect code that was not previously formatted by _Black_ (#3155) + +### Stable style + +- Fix an infinite loop when using `# fmt: on/off` in the middle of an expression or code + block (#3158) +- Fix incorrect handling of `# fmt: skip` on colon (`:`) lines (#3148) +- Comments are no longer deleted when a line had spaces removed around power operators + (#2874) + +### Preview style + +- Single-character closing docstring quotes are no longer moved to their own line as + this is invalid. This was a bug introduced in version 22.6.0. (#3166) +- `--skip-string-normalization` / `-S` now prevents docstring prefixes from being + normalized as expected (#3168) +- When using `--skip-magic-trailing-comma` or `-C`, trailing commas are stripped from + subscript expressions with more than 1 element (#3209) +- Implicitly concatenated strings inside a list, set, or tuple are now wrapped inside + parentheses (#3162) +- Fix a string merging/split issue when a comment is present in the middle of implicitly + concatenated strings on its own line (#3227) + +### _Blackd_ + +- `blackd` now supports enabling the preview style via the `X-Preview` header (#3217) + +### Configuration + +- Black now uses the presence of debug f-strings to detect target version (#3215) +- Fix misdetection of project root and verbose logging of sources in cases involving + `--stdin-filename` (#3216) +- Immediate `.gitignore` files in source directories given on the command line are now + also respected, previously only `.gitignore` files in the project root and + automatically discovered directories were respected (#3237) + +### Documentation + +- Recommend using BlackConnect in IntelliJ IDEs (#3150) + +### Integrations + +- Vim plugin: prefix messages with `Black: ` so it's clear they come from Black (#3194) +- Docker: changed to a /opt/venv installation + added to PATH to be available to + non-root users (#3202) + +### Output + +- Change from deprecated `asyncio.get_event_loop()` to create our event loop which + removes DeprecationWarning (#3164) +- Remove logging from internal `blib2to3` library since it regularly emits error logs + about failed caching that can and should be ignored (#3193) + +### Parser + +- Type comments are now included in the AST equivalence check consistently so accidental + deletion raises an error. Though type comments can't be tracked when running on PyPy + 3.7 due to standard library limitations. (#2874) + +### Performance + +- Reduce Black's startup time when formatting a single file by 15-30% (#3211) + +## Version 22.6.0 + +### Style + +- Fix unstable formatting involving `#fmt: skip` and `# fmt:skip` comments (notice the + lack of spaces) (#2970) + +### Preview style + +- Docstring quotes are no longer moved if it would violate the line length limit (#3044) +- Parentheses around return annotations are now managed (#2990) +- Remove unnecessary parentheses around awaited objects (#2991) +- Remove unnecessary parentheses in `with` statements (#2926) +- Remove trailing newlines after code block open (#3035) + +### Integrations + +- Add `scripts/migrate-black.py` script to ease introduction of Black to a Git project + (#3038) + +### Output + +- Output Python version and implementation as part of `--version` flag (#2997) + +### Packaging + +- Use `tomli` instead of `tomllib` on Python 3.11 builds where `tomllib` is not + available (#2987) + +### Parser + +- [PEP 654](https://peps.python.org/pep-0654/#except) syntax (for example, + `except *ExceptionGroup:`) is now supported (#3016) +- [PEP 646](https://peps.python.org/pep-0646) syntax (for example, + `Array[Batch, *Shape]` or `def fn(*args: *T) -> None`) is now supported (#3071) + +### Vim Plugin + +- Fix `strtobool` function. It didn't parse true/on/false/off. (#3025) + +## Version 22.3.0 + +### Preview style + +- Code cell separators `#%%` are now standardised to `# %%` (#2919) +- Remove unnecessary parentheses from `except` statements (#2939) +- Remove unnecessary parentheses from tuple unpacking in `for` loops (#2945) +- Avoid magic-trailing-comma in single-element subscripts (#2942) + +### Configuration + +- Do not format `__pypackages__` directories by default (#2836) +- Add support for specifying stable version with `--required-version` (#2832). +- Avoid crashing when the user has no homedir (#2814) +- Avoid crashing when md5 is not available (#2905) +- Fix handling of directory junctions on Windows (#2904) + +### Documentation + +- Update pylint config documentation (#2931) + +### Integrations + +- Move test to disable plugin in Vim/Neovim, which speeds up loading (#2896) + +### Output + +- In verbose mode, log when _Black_ is using user-level config (#2861) + +### Packaging + +- Fix Black to work with Click 8.1.0 (#2966) +- On Python 3.11 and newer, use the standard library's `tomllib` instead of `tomli` + (#2903) +- `black-primer`, the deprecated internal devtool, has been removed and copied to a + [separate repository](https://github.com/cooperlees/black-primer) (#2924) + +### Parser + +- Black can now parse starred expressions in the target of `for` and `async for` + statements, e.g `for item in *items_1, *items_2: pass` (#2879). + +## Version 22.1.0 + +At long last, _Black_ is no longer a beta product! This is the first non-beta release +and the first release covered by our new +[stability policy](https://black.readthedocs.io/en/stable/the_black_code_style/index.html#stability-policy). + +### Highlights + +- **Remove Python 2 support** (#2740) +- Introduce the `--preview` flag (#2752) + +### Style + +- Deprecate `--experimental-string-processing` and move the functionality under + `--preview` (#2789) +- For stubs, one blank line between class attributes and methods is now kept if there's + at least one pre-existing blank line (#2736) +- Black now normalizes string prefix order (#2297) +- Remove spaces around power operators if both operands are simple (#2726) +- Work around bug that causes unstable formatting in some cases in the presence of the + magic trailing comma (#2807) +- Use parentheses for attribute access on decimal float and int literals (#2799) +- Don't add whitespace for attribute access on hexadecimal, binary, octal, and complex + literals (#2799) +- Treat blank lines in stubs the same inside top-level `if` statements (#2820) +- Fix unstable formatting with semicolons and arithmetic expressions (#2817) +- Fix unstable formatting around magic trailing comma (#2572) + +### Parser + +- Fix mapping cases that contain as-expressions, like `case {"key": 1 | 2 as password}` + (#2686) +- Fix cases that contain multiple top-level as-expressions, like `case 1 as a, 2 as b` + (#2716) +- Fix call patterns that contain as-expressions with keyword arguments, like + `case Foo(bar=baz as quux)` (#2749) +- Tuple unpacking on `return` and `yield` constructs now implies 3.8+ (#2700) +- Unparenthesized tuples on annotated assignments (e.g + `values: Tuple[int, ...] = 1, 2, 3`) now implies 3.8+ (#2708) +- Fix handling of standalone `match()` or `case()` when there is a trailing newline or a + comment inside of the parentheses. (#2760) +- `from __future__ import annotations` statement now implies Python 3.7+ (#2690) + +### Performance + +- Speed-up the new backtracking parser about 4X in general (enabled when + `--target-version` is set to 3.10 and higher). (#2728) +- _Black_ is now compiled with [mypyc](https://github.com/mypyc/mypyc) for an overall 2x + speed-up. 64-bit Windows, MacOS, and Linux (not including musl) are supported. (#1009, + #2431) + +### Configuration + +- Do not accept bare carriage return line endings in pyproject.toml (#2408) +- Add configuration option (`python-cell-magics`) to format cells with custom magics in + Jupyter Notebooks (#2744) +- Allow setting custom cache directory on all platforms with environment variable + `BLACK_CACHE_DIR` (#2739). +- Enable Python 3.10+ by default, without any extra need to specify + `--target-version=py310`. (#2758) +- Make passing `SRC` or `--code` mandatory and mutually exclusive (#2804) + +### Output + +- Improve error message for invalid regular expression (#2678) +- Improve error message when parsing fails during AST safety check by embedding the + underlying SyntaxError (#2693) +- No longer color diff headers white as it's unreadable in light themed terminals + (#2691) +- Text coloring added in the final statistics (#2712) +- Verbose mode also now describes how a project root was discovered and which paths will + be formatted. (#2526) + +### Packaging + +- All upper version bounds on dependencies have been removed (#2718) +- `typing-extensions` is no longer a required dependency in Python 3.10+ (#2772) +- Set `click` lower bound to `8.0.0` (#2791) + +### Integrations + +- Update GitHub action to support containerized runs (#2748) + +### Documentation + +- Change protocol in pip installation instructions to `https://` (#2761) +- Change HTML theme to Furo primarily for its responsive design and mobile support + (#2793) +- Deprecate the `black-primer` tool (#2809) +- Document Python support policy (#2819) + +## Version 21.12b0 + +### _Black_ + +- Fix determination of f-string expression spans (#2654) +- Fix bad formatting of error messages about EOF in multi-line statements (#2343) +- Functions and classes in blocks now have more consistent surrounding spacing (#2472) + +#### Jupyter Notebook support + +- Cell magics are now only processed if they are known Python cell magics. Earlier, all + cell magics were tokenized, leading to possible indentation errors e.g. with + `%%writefile`. (#2630) +- Fix assignment to environment variables in Jupyter Notebooks (#2642) + +#### Python 3.10 support + +- Point users to using `--target-version py310` if we detect 3.10-only syntax (#2668) +- Fix `match` statements with open sequence subjects, like `match a, b:` or + `match a, *b:` (#2639) (#2659) +- Fix `match`/`case` statements that contain `match`/`case` soft keywords multiple + times, like `match re.match()` (#2661) +- Fix `case` statements with an inline body (#2665) +- Fix styling of starred expressions inside `match` subject (#2667) +- Fix parser error location on invalid syntax in a `match` statement (#2649) +- Fix Python 3.10 support on platforms without ProcessPoolExecutor (#2631) +- Improve parsing performance on code that uses `match` under `--target-version py310` + up to ~50% (#2670) + +### Packaging + +- Remove dependency on `regex` (#2644) (#2663) + +## Version 21.11b1 + +### _Black_ + +- Bumped regex version minimum to 2021.4.4 to fix Pattern class usage (#2621) + +## Version 21.11b0 + +### _Black_ + +- Warn about Python 2 deprecation in more cases by improving Python 2 only syntax + detection (#2592) +- Add experimental PyPy support (#2559) +- Add partial support for the match statement. As it's experimental, it's only enabled + when `--target-version py310` is explicitly specified (#2586) +- Add support for parenthesized with (#2586) +- Declare support for Python 3.10 for running Black (#2562) + +### Integrations + +- Fixed vim plugin with Python 3.10 by removing deprecated distutils import (#2610) +- The vim plugin now parses `skip_magic_trailing_comma` from pyproject.toml (#2613) + +## Version 21.10b0 + +### _Black_ + +- Document stability policy, that will apply for non-beta releases (#2529) +- Add new `--workers` parameter (#2514) +- Fixed feature detection for positional-only arguments in lambdas (#2532) +- Bumped typed-ast version minimum to 1.4.3 for 3.10 compatibility (#2519) +- Fixed a Python 3.10 compatibility issue where the loop argument was still being passed + even though it has been removed (#2580) +- Deprecate Python 2 formatting support (#2523) + +### _Blackd_ + +- Remove dependency on aiohttp-cors (#2500) +- Bump required aiohttp version to 3.7.4 (#2509) + +### _Black-Primer_ + +- Add primer support for --projects (#2555) +- Print primer summary after individual failures (#2570) + +### Integrations + +- Allow to pass `target_version` in the vim plugin (#1319) +- Install build tools in docker file and use multi-stage build to keep the image size + down (#2582) + +## Version 21.9b0 + +### Packaging + +- Fix missing modules in self-contained binaries (#2466) +- Fix missing toml extra used during installation (#2475) + +## Version 21.8b0 + +### _Black_ + +- Add support for formatting Jupyter Notebook files (#2357) +- Move from `appdirs` dependency to `platformdirs` (#2375) +- Present a more user-friendly error if .gitignore is invalid (#2414) +- The failsafe for accidentally added backslashes in f-string expressions has been + hardened to handle more edge cases during quote normalization (#2437) +- Avoid changing a function return type annotation's type to a tuple by adding a + trailing comma (#2384) +- Parsing support has been added for unparenthesized walruses in set literals, set + comprehensions, and indices (#2447). +- Pin `setuptools-scm` build-time dependency version (#2457) +- Exclude typing-extensions version 3.10.0.1 due to it being broken on Python 3.10 + (#2460) + +### _Blackd_ + +- Replace sys.exit(-1) with raise ImportError as it plays more nicely with tools that + scan installed packages (#2440) + +### Integrations + +- The provided pre-commit hooks no longer specify `language_version` to avoid overriding + `default_language_version` (#2430) + +## Version 21.7b0 + +### _Black_ + +- Configuration files using TOML features higher than spec v0.5.0 are now supported + (#2301) +- Add primer support and test for code piped into black via STDIN (#2315) +- Fix internal error when `FORCE_OPTIONAL_PARENTHESES` feature is enabled (#2332) +- Accept empty stdin (#2346) +- Provide a more useful error when parsing fails during AST safety checks (#2304) + +### Docker + +- Add new `latest_release` tag automation to follow latest black release on docker + images (#2374) + +### Integrations + +- The vim plugin now searches upwards from the directory containing the current buffer + instead of the current working directory for pyproject.toml. (#1871) +- The vim plugin now reads the correct string normalization option in pyproject.toml + (#1869) +- The vim plugin no longer crashes Black when there's boolean values in pyproject.toml + (#1869) + +## Version 21.6b0 + +### _Black_ + +- Fix failure caused by `fmt: skip` and indentation (#2281) +- Account for += assignment when deciding whether to split string (#2312) +- Correct max string length calculation when there are string operators (#2292) +- Fixed option usage when using the `--code` flag (#2259) +- Do not call `uvloop.install()` when _Black_ is used as a library (#2303) +- Added `--required-version` option to require a specific version to be running (#2300) +- Fix incorrect custom breakpoint indices when string group contains fake f-strings + (#2311) +- Fix regression where `R` prefixes would be lowercased for docstrings (#2285) +- Fix handling of named escapes (`\N{...}`) when `--experimental-string-processing` is + used (#2319) + +### Integrations + +- The official Black action now supports choosing what version to use, and supports the + major 3 OSes. (#1940) + +## Version 21.5b2 + +### _Black_ + +- A space is no longer inserted into empty docstrings (#2249) +- Fix handling of .gitignore files containing non-ASCII characters on Windows (#2229) +- Respect `.gitignore` files in all levels, not only `root/.gitignore` file (apply + `.gitignore` rules like `git` does) (#2225) +- Restored compatibility with Click 8.0 on Python 3.6 when LANG=C used (#2227) +- Add extra uvloop install + import support if in python env (#2258) +- Fix --experimental-string-processing crash when matching parens are not found (#2283) +- Make sure to split lines that start with a string operator (#2286) +- Fix regular expression that black uses to identify f-expressions (#2287) + +### _Blackd_ + +- Add a lower bound for the `aiohttp-cors` dependency. Only 0.4.0 or higher is + supported. (#2231) + +### Packaging + +- Release self-contained x86_64 MacOS binaries as part of the GitHub release pipeline + (#2198) +- Always build binaries with the latest available Python (#2260) + +### Documentation + +- Add discussion of magic comments to FAQ page (#2272) +- `--experimental-string-processing` will be enabled by default in the future (#2273) +- Fix typos discovered by codespell (#2228) +- Fix Vim plugin installation instructions. (#2235) +- Add new Frequently Asked Questions page (#2247) +- Fix encoding + symlink issues preventing proper build on Windows (#2262) + +## Version 21.5b1 + +### _Black_ + +- Refactor `src/black/__init__.py` into many files (#2206) + +### Documentation + +- Replaced all remaining references to the + [`master`](https://github.com/psf/black/tree/main) branch with the + [`main`](https://github.com/psf/black/tree/main) branch. Some additional changes in + the source code were also made. (#2210) +- Significantly reorganized the documentation to make much more sense. Check them out by + heading over to [the stable docs on RTD](https://black.readthedocs.io/en/stable/). + (#2174) + +## Version 21.5b0 + +### _Black_ + +- Set `--pyi` mode if `--stdin-filename` ends in `.pyi` (#2169) +- Stop detecting target version as Python 3.9+ with pre-PEP-614 decorators that are + being called but with no arguments (#2182) + +### _Black-Primer_ + +- Add `--no-diff` to black-primer to suppress formatting changes (#2187) + +## Version 21.4b2 + +### _Black_ + +- Fix crash if the user configuration directory is inaccessible. (#2158) + +- Clarify + [circumstances](https://github.com/psf/black/blob/master/docs/the_black_code_style.md#pragmatism) + in which _Black_ may change the AST (#2159) + +- Allow `.gitignore` rules to be overridden by specifying `exclude` in `pyproject.toml` + or on the command line. (#2170) + +### _Packaging_ + +- Install `primer.json` (used by `black-primer` by default) with black. (#2154) + +## Version 21.4b1 + +### _Black_ + +- Fix crash on docstrings ending with "\\ ". (#2142) + +- Fix crash when atypical whitespace is cleaned out of dostrings (#2120) + +- Reflect the `--skip-magic-trailing-comma` and `--experimental-string-processing` flags + in the name of the cache file. Without this fix, changes in these flags would not take + effect if the cache had already been populated. (#2131) + +- Don't remove necessary parentheses from assignment expression containing assert / + return statements. (#2143) + +### _Packaging_ + +- Bump pathspec to >= 0.8.1 to solve invalid .gitignore exclusion handling + +## Version 21.4b0 + +### _Black_ + +- Fixed a rare but annoying formatting instability created by the combination of + optional trailing commas inserted by `Black` and optional parentheses looking at + pre-existing "magic" trailing commas. This fixes issue #1629 and all of its many many + duplicates. (#2126) + +- `Black` now processes one-line docstrings by stripping leading and trailing spaces, + and adding a padding space when needed to break up """". (#1740) + +- `Black` now cleans up leading non-breaking spaces in comments (#2092) + +- `Black` now respects `--skip-string-normalization` when normalizing multiline + docstring quotes (#1637) + +- `Black` no longer removes all empty lines between non-function code and decorators + when formatting typing stubs. Now `Black` enforces a single empty line. (#1646) + +- `Black` no longer adds an incorrect space after a parenthesized assignment expression + in if/while statements (#1655) + +- Added `--skip-magic-trailing-comma` / `-C` to avoid using trailing commas as a reason + to split lines (#1824) + +- fixed a crash when PWD=/ on POSIX (#1631) + +- fixed "I/O operation on closed file" when using --diff (#1664) + +- Prevent coloured diff output being interleaved with multiple files (#1673) + +- Added support for PEP 614 relaxed decorator syntax on python 3.9 (#1711) + +- Added parsing support for unparenthesized tuples and yield expressions in annotated + assignments (#1835) + +- added `--extend-exclude` argument (PR #2005) + +- speed up caching by avoiding pathlib (#1950) + +- `--diff` correctly indicates when a file doesn't end in a newline (#1662) + +- Added `--stdin-filename` argument to allow stdin to respect `--force-exclude` rules + (#1780) + +- Lines ending with `fmt: skip` will now be not formatted (#1800) + +- PR #2053: Black no longer relies on typed-ast for Python 3.8 and higher + +- PR #2053: Python 2 support is now optional, install with + `python3 -m pip install black[python2]` to maintain support. + +- Exclude `venv` directory by default (#1683) + +- Fixed "Black produced code that is not equivalent to the source" when formatting + Python 2 docstrings (#2037) + +### _Packaging_ + +- Self-contained native _Black_ binaries are now provided for releases via GitHub + Releases (#1743) + +## Version 20.8b1 + +### _Packaging_ + +- explicitly depend on Click 7.1.2 or newer as `Black` no longer works with versions + older than 7.0 + +## Version 20.8b0 + +### _Black_ + +- re-implemented support for explicit trailing commas: now it works consistently within + any bracket pair, including nested structures (#1288 and duplicates) + +- `Black` now reindents docstrings when reindenting code around it (#1053) + +- `Black` now shows colored diffs (#1266) + +- `Black` is now packaged using 'py3' tagged wheels (#1388) + +- `Black` now supports Python 3.8 code, e.g. star expressions in return statements + (#1121) + +- `Black` no longer normalizes capital R-string prefixes as those have a + community-accepted meaning (#1244) + +- `Black` now uses exit code 2 when specified configuration file doesn't exit (#1361) + +- `Black` now works on AWS Lambda (#1141) + +- added `--force-exclude` argument (#1032) + +- removed deprecated `--py36` option (#1236) + +- fixed `--diff` output when EOF is encountered (#526) + +- fixed `# fmt: off` handling around decorators (#560) + +- fixed unstable formatting with some `# type: ignore` comments (#1113) + +- fixed invalid removal on organizing brackets followed by indexing (#1575) + +- introduced `black-primer`, a CI tool that allows us to run regression tests against + existing open source users of Black (#1402) + +- introduced property-based fuzzing to our test suite based on Hypothesis and + Hypothersmith (#1566) + +- implemented experimental and disabled by default long string rewrapping (#1132), + hidden under a `--experimental-string-processing` flag while it's being worked on; + this is an undocumented and unsupported feature, you lose Internet points for + depending on it (#1609) + +### Vim plugin + +- prefer virtualenv packages over global packages (#1383) + +## Version 19.10b0 + +- added support for PEP 572 assignment expressions (#711) + +- added support for PEP 570 positional-only arguments (#943) + +- added support for async generators (#593) + +- added support for pre-splitting collections by putting an explicit trailing comma + inside (#826) + +- added `black -c` as a way to format code passed from the command line (#761) + +- --safe now works with Python 2 code (#840) + +- fixed grammar selection for Python 2-specific code (#765) + +- fixed feature detection for trailing commas in function definitions and call sites + (#763) + +- `# fmt: off`/`# fmt: on` comment pairs placed multiple times within the same block of + code now behave correctly (#1005) + +- _Black_ no longer crashes on Windows machines with more than 61 cores (#838) + +- _Black_ no longer crashes on standalone comments prepended with a backslash (#767) + +- _Black_ no longer crashes on `from` ... `import` blocks with comments (#829) + +- _Black_ no longer crashes on Python 3.7 on some platform configurations (#494) + +- _Black_ no longer fails on comments in from-imports (#671) + +- _Black_ no longer fails when the file starts with a backslash (#922) + +- _Black_ no longer merges regular comments with type comments (#1027) + +- _Black_ no longer splits long lines that contain type comments (#997) + +- removed unnecessary parentheses around `yield` expressions (#834) + +- added parentheses around long tuples in unpacking assignments (#832) + +- added parentheses around complex powers when they are prefixed by a unary operator + (#646) + +- fixed bug that led _Black_ format some code with a line length target of 1 (#762) + +- _Black_ no longer introduces quotes in f-string subexpressions on string boundaries + (#863) + +- if _Black_ puts parenthesis around a single expression, it moves comments to the + wrapped expression instead of after the brackets (#872) + +- `blackd` now returns the version of _Black_ in the response headers (#1013) + +- `blackd` can now output the diff of formats on source code when the `X-Diff` header is + provided (#969) + +## Version 19.3b0 + +- new option `--target-version` to control which Python versions _Black_-formatted code + should target (#618) + +- deprecated `--py36` (use `--target-version=py36` instead) (#724) + +- _Black_ no longer normalizes numeric literals to include `_` separators (#696) + +- long `del` statements are now split into multiple lines (#698) + +- type comments are no longer mangled in function signatures + +- improved performance of formatting deeply nested data structures (#509) + +- _Black_ now properly formats multiple files in parallel on Windows (#632) + +- _Black_ now creates cache files atomically which allows it to be used in parallel + pipelines (like `xargs -P8`) (#673) + +- _Black_ now correctly indents comments in files that were previously formatted with + tabs (#262) + +- `blackd` now supports CORS (#622) + +## Version 18.9b0 + +- numeric literals are now formatted by _Black_ (#452, #461, #464, #469): + - numeric literals are normalized to include `_` separators on Python 3.6+ code + + - added `--skip-numeric-underscore-normalization` to disable the above behavior and + leave numeric underscores as they were in the input + + - code with `_` in numeric literals is recognized as Python 3.6+ + + - most letters in numeric literals are lowercased (e.g., in `1e10`, `0x01`) + + - hexadecimal digits are always uppercased (e.g. `0xBADC0DE`) + +- added `blackd`, see + [its documentation](https://github.com/psf/black/blob/18.9b0/README.md#blackd) for + more info (#349) + +- adjacent string literals are now correctly split into multiple lines (#463) + +- trailing comma is now added to single imports that don't fit on a line (#250) + +- cache is now populated when `--check` is successful for a file which speeds up + consecutive checks of properly formatted unmodified files (#448) + +- whitespace at the beginning of the file is now removed (#399) + +- fixed mangling [pweave](http://mpastell.com/pweave/) and + [Spyder IDE](https://www.spyder-ide.org/) special comments (#532) + +- fixed unstable formatting when unpacking big tuples (#267) + +- fixed parsing of `__future__` imports with renames (#389) + +- fixed scope of `# fmt: off` when directly preceding `yield` and other nodes (#385) + +- fixed formatting of lambda expressions with default arguments (#468) + +- fixed `async for` statements: _Black_ no longer breaks them into separate lines (#372) + +- note: the Vim plugin stopped registering `,=` as a default chord as it turned out to + be a bad idea (#415) + +## Version 18.6b4 + +- hotfix: don't freeze when multiple comments directly precede `# fmt: off` (#371) + +## Version 18.6b3 + +- typing stub files (`.pyi`) now have blank lines added after constants (#340) + +- `# fmt: off` and `# fmt: on` are now much more dependable: + - they now work also within bracket pairs (#329) + + - they now correctly work across function/class boundaries (#335) + + - they now work when an indentation block starts with empty lines or misaligned + comments (#334) + +- made Click not fail on invalid environments; note that Click is right but the + likelihood we'll need to access non-ASCII file paths when dealing with Python source + code is low (#277) + +- fixed improper formatting of f-strings with quotes inside interpolated expressions + (#322) + +- fixed unnecessary slowdown when long list literals where found in a file + +- fixed unnecessary slowdown on AST nodes with very many siblings + +- fixed cannibalizing backslashes during string normalization + +- fixed a crash due to symbolic links pointing outside of the project directory (#338) + +## Version 18.6b2 + +- added `--config` (#65) + +- added `-h` equivalent to `--help` (#316) + +- fixed improper unmodified file caching when `-S` was used + +- fixed extra space in string unpacking (#305) + +- fixed formatting of empty triple quoted strings (#313) + +- fixed unnecessary slowdown in comment placement calculation on lines without comments + +## Version 18.6b1 + +- hotfix: don't output human-facing information on stdout (#299) + +- hotfix: don't output cake emoji on non-zero return code (#300) + +## Version 18.6b0 + +- added `--include` and `--exclude` (#270) + +- added `--skip-string-normalization` (#118) + +- added `--verbose` (#283) + +- the header output in `--diff` now actually conforms to the unified diff spec + +- fixed long trivial assignments being wrapped in unnecessary parentheses (#273) + +- fixed unnecessary parentheses when a line contained multiline strings (#232) + +- fixed stdin handling not working correctly if an old version of Click was used (#276) + +- _Black_ now preserves line endings when formatting a file in place (#258) + +## Version 18.5b1 + +- added `--pyi` (#249) + +- added `--py36` (#249) + +- Python grammar pickle caches are stored with the formatting caches, making _Black_ + work in environments where site-packages is not user-writable (#192) + +- _Black_ now enforces a PEP 257 empty line after a class-level docstring (and/or + fields) and the first method + +- fixed invalid code produced when standalone comments were present in a trailer that + was omitted from line splitting on a large expression (#237) + +- fixed optional parentheses being removed within `# fmt: off` sections (#224) + +- fixed invalid code produced when stars in very long imports were incorrectly wrapped + in optional parentheses (#234) + +- fixed unstable formatting when inline comments were moved around in a trailer that was + omitted from line splitting on a large expression (#238) + +- fixed extra empty line between a class declaration and the first method if no class + docstring or fields are present (#219) + +- fixed extra empty line between a function signature and an inner function or inner + class (#196) + +## Version 18.5b0 + +- call chains are now formatted according to the + [fluent interfaces](https://en.wikipedia.org/wiki/Fluent_interface) style (#67) + +- data structure literals (tuples, lists, dictionaries, and sets) are now also always + exploded like imports when they don't fit in a single line (#152) + +- slices are now formatted according to PEP 8 (#178) + +- parentheses are now also managed automatically on the right-hand side of assignments + and return statements (#140) + +- math operators now use their respective priorities for delimiting multiline + expressions (#148) + +- optional parentheses are now omitted on expressions that start or end with a bracket + and only contain a single operator (#177) + +- empty parentheses in a class definition are now removed (#145, #180) + +- string prefixes are now standardized to lowercase and `u` is removed on Python 3.6+ + only code and Python 2.7+ code with the `unicode_literals` future import (#188, #198, + #199) + +- typing stub files (`.pyi`) are now formatted in a style that is consistent with PEP + 484 (#207, #210) + +- progress when reformatting many files is now reported incrementally + +- fixed trailers (content with brackets) being unnecessarily exploded into their own + lines after a dedented closing bracket (#119) + +- fixed an invalid trailing comma sometimes left in imports (#185) + +- fixed non-deterministic formatting when multiple pairs of removable parentheses were + used (#183) + +- fixed multiline strings being unnecessarily wrapped in optional parentheses in long + assignments (#215) + +- fixed not splitting long from-imports with only a single name + +- fixed Python 3.6+ file discovery by also looking at function calls with unpacking. + This fixed non-deterministic formatting if trailing commas where used both in function + signatures with stars and function calls with stars but the former would be + reformatted to a single line. + +- fixed crash on dealing with optional parentheses (#193) + +- fixed "is", "is not", "in", and "not in" not considered operators for splitting + purposes + +- fixed crash when dead symlinks where encountered + +## Version 18.4a4 + +- don't populate the cache on `--check` (#175) + +## Version 18.4a3 + +- added a "cache"; files already reformatted that haven't changed on disk won't be + reformatted again (#109) + +- `--check` and `--diff` are no longer mutually exclusive (#149) + +- generalized star expression handling, including double stars; this fixes + multiplication making expressions "unsafe" for trailing commas (#132) + +- _Black_ no longer enforces putting empty lines behind control flow statements (#90) + +- _Black_ now splits imports like "Mode 3 + trailing comma" of isort (#127) + +- fixed comment indentation when a standalone comment closes a block (#16, #32) + +- fixed standalone comments receiving extra empty lines if immediately preceding a + class, def, or decorator (#56, #154) + +- fixed `--diff` not showing entire path (#130) + +- fixed parsing of complex expressions after star and double stars in function calls + (#2) + +- fixed invalid splitting on comma in lambda arguments (#133) + +- fixed missing splits of ternary expressions (#141) + +## Version 18.4a2 + +- fixed parsing of unaligned standalone comments (#99, #112) + +- fixed placement of dictionary unpacking inside dictionary literals (#111) + +- Vim plugin now works on Windows, too + +- fixed unstable formatting when encountering unnecessarily escaped quotes in a string + (#120) + +## Version 18.4a1 + +- added `--quiet` (#78) + +- added automatic parentheses management (#4) + +- added [pre-commit](https://pre-commit.com) integration (#103, #104) + +- fixed reporting on `--check` with multiple files (#101, #102) + +- fixed removing backslash escapes from raw strings (#100, #105) + +## Version 18.4a0 + +- added `--diff` (#87) + +- add line breaks before all delimiters, except in cases like commas, to better comply + with PEP 8 (#73) + +- standardize string literals to use double quotes (almost) everywhere (#75) + +- fixed handling of standalone comments within nested bracketed expressions; _Black_ + will no longer produce super long lines or put all standalone comments at the end of + the expression (#22) + +- fixed 18.3a4 regression: don't crash and burn on empty lines with trailing whitespace + (#80) + +- fixed 18.3a4 regression: `# yapf: disable` usage as trailing comment would cause + _Black_ to not emit the rest of the file (#95) + +- when CTRL+C is pressed while formatting many files, _Black_ no longer freaks out with + a flurry of asyncio-related exceptions + +- only allow up to two empty lines on module level and only single empty lines within + functions (#74) + +## Version 18.3a4 + +- `# fmt: off` and `# fmt: on` are implemented (#5) + +- automatic detection of deprecated Python 2 forms of print statements and exec + statements in the formatted file (#49) + +- use proper spaces for complex expressions in default values of typed function + arguments (#60) + +- only return exit code 1 when --check is used (#50) + +- don't remove single trailing commas from square bracket indexing (#59) + +- don't omit whitespace if the previous factor leaf wasn't a math operator (#55) + +- omit extra space in kwarg unpacking if it's the first argument (#46) + +- omit extra space in + [Sphinx auto-attribute comments](http://www.sphinx-doc.org/en/stable/ext/autodoc.html#directive-autoattribute) + (#68) + +## Version 18.3a3 + +- don't remove single empty lines outside of bracketed expressions (#19) + +- added ability to pipe formatting from stdin to stdin (#25) + +- restored ability to format code with legacy usage of `async` as a name (#20, #42) + +- even better handling of numpy-style array indexing (#33, again) + +## Version 18.3a2 + +- changed positioning of binary operators to occur at beginning of lines instead of at + the end, following + [a recent change to PEP 8](https://github.com/python/peps/commit/c59c4376ad233a62ca4b3a6060c81368bd21e85b) + (#21) + +- ignore empty bracket pairs while splitting. This avoids very weirdly looking + formattings (#34, #35) + +- remove a trailing comma if there is a single argument to a call + +- if top level functions were separated by a comment, don't put four empty lines after + the upper function + +- fixed unstable formatting of newlines with imports + +- fixed unintentional folding of post scriptum standalone comments into last statement + if it was a simple statement (#18, #28) + +- fixed missing space in numpy-style array indexing (#33) + +- fixed spurious space after star-based unary expressions (#31) + +## Version 18.3a1 + +- added `--check` + +- only put trailing commas in function signatures and calls if it's safe to do so. If + the file is Python 3.6+ it's always safe, otherwise only safe if there are no `*args` + or `**kwargs` used in the signature or call. (#8) + +- fixed invalid spacing of dots in relative imports (#6, #13) + +- fixed invalid splitting after comma on unpacked variables in for-loops (#23) + +- fixed spurious space in parenthesized set expressions (#7) + +- fixed spurious space after opening parentheses and in default arguments (#14, #17) + +- fixed spurious space after unary operators when the operand was a complex expression + (#15) + +## Version 18.3a0 + +- first published version, Happy 🍰 Day 2018! + +- alpha quality + +- date-versioned (see: ) diff --git a/CITATION.cff b/CITATION.cff new file mode 100644 index 0000000..7ff0e3c --- /dev/null +++ b/CITATION.cff @@ -0,0 +1,22 @@ +cff-version: 1.2.0 +title: "Black: The uncompromising Python code formatter" +message: >- + If you use this software, please cite it using the metadata from this file. +type: software +authors: + - family-names: Langa + given-names: Łukasz + - name: "contributors to Black" +repository-code: "https://github.com/psf/black" +url: "https://black.readthedocs.io/en/stable/" +abstract: >- + Black is the uncompromising Python code formatter. By using it, you agree to cede + control over minutiae of hand-formatting. In return, Black gives you speed, + determinism, and freedom from pycodestyle nagging about formatting. You will save time + and mental energy for more important matters. + + Blackened code looks the same regardless of the project you're reading. Formatting + becomes transparent after a while and you can focus on the content instead. + + Black makes code review faster by producing the smallest diffs possible. +license: MIT diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..7d97db9 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,13 @@ +# Contributing to _Black_ + +Welcome future contributor! We're happy to see you willing to make the project better. + +If you aren't familiar with _Black_, or are looking for documentation on something +specific, the [user documentation](https://black.readthedocs.io/en/stable/) is the best +place to look. + +For getting started on contributing, please read the +[contributing documentation](https://black.readthedocs.io/en/latest/contributing/) for +all you need to know. + +Thank you, and we look forward to your contributions! diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..e455931 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,25 @@ +FROM python:3.13-slim AS builder + +RUN mkdir /src +COPY . /src/ +ENV VIRTUAL_ENV=/opt/venv +ENV HATCH_BUILD_HOOKS_ENABLE=1 +# Install build tools to compile black + dependencies +RUN apt update && apt install -y build-essential git python3-dev + +ENV PATH="$VIRTUAL_ENV/bin:$PATH" +RUN python -m venv $VIRTUAL_ENV +RUN cd /src \ + && pip install --no-cache-dir --upgrade pip \ + && pip install --no-cache-dir --group hatch \ + && hatch build -t wheel \ + && pip install --no-cache-dir dist/*-cp* \ + && pip install black[colorama,d,uvloop] + +FROM python:3.13-slim + +# copy only Python packages to limit the image size +COPY --from=builder /opt/venv /opt/venv +ENV PATH="/opt/venv/bin:$PATH" + +CMD ["/opt/venv/bin/black"] diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..7a9b891 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2018 Łukasz Langa + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/README.md b/README.md new file mode 100644 index 0000000..ec7eb91 --- /dev/null +++ b/README.md @@ -0,0 +1,231 @@ +[![Black Logo](https://raw.githubusercontent.com/psf/black/main/docs/_static/logo2-readme.png)](https://black.readthedocs.io/en/stable/) + +

The Uncompromising Code Formatter

+ +

+Actions Status +Documentation Status +Coverage Status +License: MIT +PyPI +Supported Python Versions +Downloads +conda-forge +Code style: black +

+ +> “Any color you like.” + +_Black_ is the uncompromising Python code formatter. By using it, you agree to cede +control over minutiae of hand-formatting. In return, _Black_ gives you speed, +determinism, and freedom from `pycodestyle` nagging about formatting. You will save time +and mental energy for more important matters. + +Blackened code looks the same regardless of the project you're reading. Formatting +becomes transparent after a while and you can focus on the content instead. + +_Black_ makes code review faster by producing the smallest diffs possible. + +Watch the [PyCon 2019 talk](https://youtu.be/esZLCuWs_2Y) to learn more. + +--- + +**[Read the documentation on ReadTheDocs!](https://black.readthedocs.io/en/stable)** + +--- + +## Installation and usage + +### Installation + +_Black_ can be installed by running `pip install black`. It requires Python 3.10+ to +run. If you want to format Jupyter Notebooks, install with +`pip install "black[jupyter]"`. + +If you want to run _Black_ without installing Python, download one of the +PyInstaller-built standalone executables from the +[latest GitHub release](https://github.com/psf/black/releases/latest). + +### Usage + +To get started right away with sensible defaults: + +```sh +black {source_file_or_directory} +``` + +You can run _Black_ as a package if running it as a script doesn't work: + +```sh +python -m black {source_file_or_directory} +``` + +Further information can be found in our docs: + +- [Usage and Configuration](https://black.readthedocs.io/en/stable/usage_and_configuration/index.html) + +_Black_ is already [successfully used](https://github.com/psf/black#used-by) by many +projects, small and big. _Black_ has a comprehensive test suite, with efficient parallel +tests, and our own auto formatting and parallel Continuous Integration runner. Now that +we have become stable, you should not expect large formatting changes in the future. +Stylistic changes will mostly be responses to bug reports and support for new Python +syntax. For more information please refer to +[The Black Code Style](https://black.readthedocs.io/en/stable/the_black_code_style/index.html). + +Also, as a safety measure which slows down processing, _Black_ will check that the +reformatted code still produces a valid AST that is effectively equivalent to the +original (see the +[Pragmatism](https://black.readthedocs.io/en/stable/the_black_code_style/current_style.html#ast-before-and-after-formatting) +section for details). If you're feeling confident, use `--fast`. + +## The _Black_ code style + +_Black_ is a PEP 8 compliant opinionated formatter. _Black_ reformats entire files in +place. Style configuration options are deliberately limited and rarely added. It doesn't +take previous formatting into account (see +[Pragmatism](https://black.readthedocs.io/en/stable/the_black_code_style/current_style.html#pragmatism) +for exceptions). + +Our documentation covers the current _Black_ code style, but planned changes to it are +also documented. They're both worth taking a look at: + +- [The _Black_ Code Style: Current style](https://black.readthedocs.io/en/stable/the_black_code_style/current_style.html) +- [The _Black_ Code Style: Future style](https://black.readthedocs.io/en/stable/the_black_code_style/future_style.html) + +Changes to the _Black_ code style are bound by the Stability Policy: + +- [The _Black_ Code Style: Stability Policy](https://black.readthedocs.io/en/stable/the_black_code_style/index.html#stability-policy) + +Please refer to this document before submitting an issue. What seems like a bug might be +intended behaviour. + +### Pragmatism + +Early versions of _Black_ used to be absolutist in some respects. They took after its +initial author. This was fine at the time as it made the implementation simpler and +there were not many users anyway. Not many edge cases were reported. As a mature tool, +_Black_ does make some exceptions to rules it otherwise holds. + +- [The _Black_ code style: Pragmatism](https://black.readthedocs.io/en/stable/the_black_code_style/current_style.html#pragmatism) + +Please refer to this document before submitting an issue just like with the document +above. What seems like a bug might be intended behaviour. + +## Configuration + +_Black_ is able to read project-specific default values for its command line options +from a `pyproject.toml` file. This is especially useful for specifying custom +`--include` and `--exclude`/`--force-exclude`/`--extend-exclude` patterns for your +project. + +You can find more details in our documentation: + +- [The basics: Configuration via a file](https://black.readthedocs.io/en/stable/usage_and_configuration/the_basics.html#configuration-via-a-file) + +And if you're looking for more general configuration documentation: + +- [Usage and Configuration](https://black.readthedocs.io/en/stable/usage_and_configuration/index.html) + +**Pro-tip**: If you're asking yourself "Do I need to configure anything?" the answer is +"No". _Black_ is all about sensible defaults. Applying those defaults will have your +code in compliance with many other _Black_ formatted projects. + +## Used by + +The following notable open-source projects trust _Black_ with enforcing a consistent +code style: pytest, tox, Pyramid, Django, Django Channels, Hypothesis, attrs, +SQLAlchemy, Poetry, PyPA applications (Warehouse, Bandersnatch, Pipenv, virtualenv), +pandas, Pillow, Twisted, LocalStack, every Datadog Agent Integration, Home Assistant, +Zulip, Kedro, OpenOA, FLORIS, ORBIT, WOMBAT, and many more. + +The following organizations use _Black_: Dropbox, KeepTruckin, Lyft, Mozilla, Quora, +Duolingo, QuantumBlack, Tesla, Archer Aviation. + +Are we missing anyone? Let us know. + +## Testimonials + +**Mike Bayer**, creator of [`SQLAlchemy`](https://www.sqlalchemy.org/): + +> I can't think of any single tool in my entire programming career that has given me a +> bigger productivity increase by its introduction. I can now do refactorings in about +> 1% of the keystrokes that it would have taken me previously when we had no way for +> code to format itself. + +**Dusty Phillips**, +[writer](https://www.amazon.com/stores/Dusty-Phillips/author/B00HSYG5BO): + +> _Black_ is opinionated so you don't have to be. + +**Hynek Schlawack**, creator of [`attrs`](https://www.attrs.org/), core developer of +Twisted and CPython: + +> An auto-formatter that doesn't suck is all I want for Xmas! + +**Carl Meyer**, [Django](https://www.djangoproject.com/) core developer: + +> At least the name is good. + +**Kenneth Reitz**, creator of [`requests`](https://requests.readthedocs.io/en/stable/) +and [pipenv](https://pipenv.pypa.io/en/stable/): + +> This vastly improves the formatting of our code. Thanks a ton! + +## Show your style + +Use the badge in your project's README.md: + +```md +[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black) +``` + +Using the badge in README.rst: + +```rst +.. image:: https://img.shields.io/badge/code%20style-black-000000.svg + :target: https://github.com/psf/black +``` + +Looks like this: +[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black) + +## License + +MIT + +## Contributing + +Welcome! Happy to see you willing to make the project better. You can get started by +reading this: + +- [Contributing: The basics](https://black.readthedocs.io/en/latest/contributing/the_basics.html) + +You can also take a look at the rest of the contributing docs or talk with the +developers: + +- [Contributing documentation](https://black.readthedocs.io/en/latest/contributing/index.html) +- [Chat on Discord](https://discord.gg/RtVdv86PrH) + +## Change log + +The log has become rather long. It moved to its own file. + +See [CHANGES](https://black.readthedocs.io/en/latest/change_log.html). + +## Authors + +The author list is quite long nowadays, so it lives in its own file. + +See [AUTHORS.md](./AUTHORS.md) + +## Code of Conduct + +Everyone participating in the _Black_ project, and in particular in the issue tracker, +pull requests, and social media activity, is expected to treat other people with respect +and more generally to follow the guidelines articulated in the +[Python Community Code of Conduct](https://www.python.org/psf/codeofconduct/). + +At the same time, humor is encouraged. In fact, basic familiarity with Monty Python's +Flying Circus is expected. We are not savages. + +And if you _really_ need to slap somebody, do it with a fish while dancing. diff --git a/README.wehub.md b/README.wehub.md new file mode 100644 index 0000000..9d4edf8 --- /dev/null +++ b/README.wehub.md @@ -0,0 +1,7 @@ +# WeHub 来源说明 + +- 原始项目：`psf/black` +- 原始仓库：https://github.com/psf/black +- 导入方式：上游默认分支的最新快照 +- 原作者、版权和许可证信息以原始仓库及本仓库 LICENSE 为准 +- 本文件仅用于记录来源，不代表 WeHub 是原项目作者 diff --git a/SECURITY.md b/SECURITY.md new file mode 100644 index 0000000..4704950 --- /dev/null +++ b/SECURITY.md @@ -0,0 +1,11 @@ +# Security Policy + +## Supported Versions + +Only the latest non-prerelease version is supported. + +## Security contact information + +To report a security vulnerability, please use the +[Tidelift security contact](https://tidelift.com/security). Tidelift will coordinate the +fix and disclosure. diff --git a/action.yml b/action.yml new file mode 100644 index 0000000..733fcbe --- /dev/null +++ b/action.yml @@ -0,0 +1,87 @@ +name: "Black" +description: "The uncompromising Python code formatter." +author: "Łukasz Langa and contributors to Black" +inputs: + options: + description: + "Options passed to Black. Use `black --help` to see available options. Default: + '--check --diff'" + required: false + default: "--check --diff" + src: + description: "Source to run Black. Default: '.'" + required: false + default: "." + jupyter: + description: + "Set this option to true to include Jupyter Notebook files. Default: false" + required: false + default: false + black_args: + description: "[DEPRECATED] Black input arguments." + required: false + default: "" + deprecationMessage: + "Input `with.black_args` is deprecated. Use `with.options` and `with.src` instead." + version: + description: 'Python Version specifier (PEP440) - e.g. "21.5b1"' + required: false + default: "" + use_pyproject: + description: Read Black version specifier from pyproject.toml if `true`. + required: false + default: "false" + summary: + description: "Whether to add the output to the workflow summary" + required: false + default: true + output-file: + description: > + Optional path to write Black output to a file in addition to stdout. Useful for + keeping GitHub Actions logs clean when using --diff or --check. + required: false + default: "" +branding: + color: "black" + icon: "check-circle" +runs: + using: composite + steps: + - name: black + run: | + # Even when black fails, do not close the shell + set +e + + if [ "$RUNNER_OS" == "Windows" ]; then + runner="python" + else + runner="python3" + fi + + out=$(${runner} $GITHUB_ACTION_PATH/action/main.py) + exit_code=$? + + # Display the raw output in the step + echo "${out}" + + if [ "${INPUT_SUMMARY}" == "true" ]; then + # Display the Markdown output in the job summary + echo "\`\`\`python" >> $GITHUB_STEP_SUMMARY + echo "${out}" >> $GITHUB_STEP_SUMMARY + echo "\`\`\`" >> $GITHUB_STEP_SUMMARY + fi + + # Exit with the exit-code returned by Black + exit ${exit_code} + env: + # TODO: Remove once https://github.com/actions/runner/issues/665 is fixed. + INPUT_OPTIONS: ${{ inputs.options }} + INPUT_SRC: ${{ inputs.src }} + INPUT_JUPYTER: ${{ inputs.jupyter }} + INPUT_BLACK_ARGS: ${{ inputs.black_args }} + INPUT_VERSION: ${{ inputs.version }} + INPUT_USE_PYPROJECT: ${{ inputs.use_pyproject }} + INPUT_SUMMARY: ${{ inputs.summary }} + OUTPUT_FILE: ${{ inputs.output-file }} + pythonioencoding: utf-8 + shell: bash diff --git a/action/main.py b/action/main.py new file mode 100644 index 0000000..7dc6ae0 --- /dev/null +++ b/action/main.py @@ -0,0 +1,201 @@ +import os +import re +import shlex +import shutil +import sys +from pathlib import Path +from subprocess import PIPE, STDOUT, run + +ACTION_PATH = Path(os.environ["GITHUB_ACTION_PATH"]) +ENV_PATH = ACTION_PATH / ".black-env" +ENV_BIN = ENV_PATH / ("Scripts" if sys.platform == "win32" else "bin") +OPTIONS = os.getenv("INPUT_OPTIONS", default="") +SRC = os.getenv("INPUT_SRC", default="") +JUPYTER = os.getenv("INPUT_JUPYTER") == "true" +BLACK_ARGS = os.getenv("INPUT_BLACK_ARGS", default="") +VERSION = os.getenv("INPUT_VERSION", default="") +USE_PYPROJECT = os.getenv("INPUT_USE_PYPROJECT") == "true" +OUTPUT_FILE = os.getenv("OUTPUT_FILE", default="") + +BLACK_VERSION_RE = re.compile( + r"^black((?:\s*(?:~=|==|!=|<=|>=|<|>|===)\s*[A-Za-z0-9*+._-]+)" + r"(?:\s*,\s*(?:~=|==|!=|<=|>=|<|>|===)\s*[A-Za-z0-9*+._-]+)*)\s*$", + re.IGNORECASE, +) +EXTRAS_RE = re.compile(r"\[.*\]") +EXPORT_SUBST_FAIL_RE = re.compile(r"\$Format:.*\$") + + +def determine_version_specifier() -> str: + """Determine the version of Black to install. + + The version can be specified either via the `with.version` input or via the + pyproject.toml file if `with.use_pyproject` is set to `true`. + """ + if USE_PYPROJECT and VERSION: + print( + "::error::'with.version' and 'with.use_pyproject' inputs are " + "mutually exclusive.", + file=sys.stderr, + flush=True, + ) + sys.exit(1) + if USE_PYPROJECT: + return read_version_specifier_from_pyproject() + elif VERSION and VERSION[0] in "0123456789": + return f"=={VERSION}" + else: + return VERSION + + +def read_version_specifier_from_pyproject() -> str: + if sys.version_info < (3, 11): + print( + "::error::'with.use_pyproject' input requires Python 3.11 or later.", + file=sys.stderr, + flush=True, + ) + sys.exit(1) + + import tomllib # type: ignore[import-not-found,unreachable] + + try: + with Path("pyproject.toml").open("rb") as fp: + pyproject = tomllib.load(fp) + except FileNotFoundError: + print( + "::error::'with.use_pyproject' input requires a pyproject.toml file.", + file=sys.stderr, + flush=True, + ) + sys.exit(1) + + version = pyproject.get("tool", {}).get("black", {}).get("required-version") + if version is not None: + # Match the two supported usages of `required-version`: + if "." in version: + return f"=={version}" + else: + return f"~={version}.0" + + arrays = [ + *pyproject.get("dependency-groups", {}).values(), + pyproject.get("project", {}).get("dependencies"), + *pyproject.get("project", {}).get("optional-dependencies", {}).values(), + ] + for array in arrays: + version = find_black_version_in_array(array) + if version is not None: + break + + if version is None: + print( + "::error::'black' dependency missing from pyproject.toml.", + file=sys.stderr, + flush=True, + ) + sys.exit(1) + + return version + + +def find_black_version_in_array(array: object) -> str | None: + if not isinstance(array, list): + return None + try: + for item in array: + # Rudimentary PEP 508 parsing. + item = item.split(";")[0] + item = EXTRAS_RE.sub("", item).strip() + if item == "black": + print( + "::error::Version specifier missing for 'black' dependency in " + "pyproject.toml.", + file=sys.stderr, + flush=True, + ) + sys.exit(1) + elif m := BLACK_VERSION_RE.match(item): + return m.group(1).strip() + except TypeError: + pass + + return None + + +run([sys.executable, "-m", "venv", str(ENV_PATH)], check=True) + +version_specifier = determine_version_specifier() +if JUPYTER: + extra_deps = "[colorama,jupyter]" +else: + extra_deps = "[colorama]" +if version_specifier: + req = f"black{extra_deps}{version_specifier}" +else: + describe_name = "" + with open(ACTION_PATH / ".git_archival.txt", encoding="utf-8") as fp: + for line in fp: + if line.startswith("describe-name: "): + describe_name = line[len("describe-name: ") :].rstrip() + break + if not describe_name: + print("::error::Failed to detect action version.", file=sys.stderr, flush=True) + sys.exit(1) + # expected format is one of: + # - 23.1.0 + # - 23.1.0-51-g448bba7 + # - $Format:%(describe:tags=true,match=*[0-9]*)$ (if export-subst fails) + if ( + describe_name.count("-") < 2 + and EXPORT_SUBST_FAIL_RE.match(describe_name) is None + ): + # the action's commit matches a tag exactly, install exact version from PyPI + req = f"black{extra_deps}=={describe_name}" + else: + # the action's commit does not match any tag, install from the local git repo + req = f".{extra_deps}" +print(f"Installing {req}...", flush=True) +pip_proc = run( + [str(ENV_BIN / "python"), "-m", "pip", "install", req], + stdout=PIPE, + stderr=STDOUT, + encoding="utf-8", + cwd=ACTION_PATH, +) +if pip_proc.returncode: + print(pip_proc.stdout) + print("::error::Failed to install Black.", file=sys.stderr, flush=True) + sys.exit(pip_proc.returncode) + + +base_cmd = [str(ENV_BIN / "black")] +if BLACK_ARGS: + # TODO: remove after a while since this is deprecated in favour of SRC + OPTIONS. + proc = run( + [*base_cmd, *shlex.split(BLACK_ARGS)], + stdout=PIPE, + stderr=STDOUT, + encoding="utf-8", + ) +else: + proc = run( + [*base_cmd, *shlex.split(OPTIONS), *shlex.split(SRC)], + stdout=PIPE, + stderr=STDOUT, + encoding="utf-8", + ) +shutil.rmtree(ENV_PATH, ignore_errors=True) + +# Write output to file if specified +if OUTPUT_FILE: + try: + with open(OUTPUT_FILE, "w", encoding="utf-8") as f: + f.write(proc.stdout) + print(f"Black output written to {OUTPUT_FILE}") + except Exception as e: + print(f"::error::Failed to write output to {OUTPUT_FILE}: {e}", file=sys.stderr) + sys.exit(1) + +print(proc.stdout) +sys.exit(proc.returncode) diff --git a/autoload/black.vim b/autoload/black.vim new file mode 100644 index 0000000..ad94c7e --- /dev/null +++ b/autoload/black.vim @@ -0,0 +1,303 @@ +python3 << EndPython3 +import collections +import os +import sys +import vim + + +def strtobool(text): + if text.lower() in ["y", "yes", "t", "true", "on", "1"]: + return True + if text.lower() in ["n", "no", "f", "false", "off", "0"]: + return False + raise ValueError(f"{text} is not convertible to boolean") + + +class Flag(collections.namedtuple("FlagBase", "name, cast")): + @property + def var_name(self): + return self.name.replace("-", "_") + + @property + def vim_rc_name(self): + name = self.var_name + if name == "line_length": + name = name.replace("_", "") + return "g:black_" + name + + +FLAGS = [ + Flag(name="line_length", cast=int), + Flag(name="fast", cast=strtobool), + Flag(name="skip_string_normalization", cast=strtobool), + Flag(name="quiet", cast=strtobool), + Flag(name="skip_magic_trailing_comma", cast=strtobool), + Flag(name="preview", cast=strtobool), +] + + +def _get_python_binary(exec_prefix, pyver): + try: + default = vim.eval("g:pymode_python").strip() + except vim.error: + default = "" + if default and os.path.exists(default): + return default + if sys.platform[:3] == "win": + return exec_prefix / "python.exe" + bin_path = exec_prefix / "bin" + exec_path = (bin_path / f"python{pyver[0]}.{pyver[1]}").resolve() + if exec_path.exists(): + return exec_path + # It is possible that some environments may only have python3 + exec_path = (bin_path / "python3").resolve() + if exec_path.exists(): + return exec_path + raise ValueError("python executable not found") + + +def _get_pip(venv_path): + if sys.platform[:3] == "win": + return venv_path / "Scripts" / "pip.exe" + return venv_path / "bin" / "pip" + + +def _get_virtualenv_site_packages(venv_path, pyver): + if sys.platform[:3] == "win": + return venv_path / "Lib" / "site-packages" + if ( + venv_path.exists() + and not (venv_path / "lib" / f"python{pyver[0]}.{pyver[1]}").exists() + ): + # The virtualenv already exists but it doesn't seem to have the expected + # Python version, so we disregard the requested `pyver` and + # discover the real Python interpreter from this virtualenv + import subprocess + + result = subprocess.run( + [_get_python_binary(venv_path, pyver), "--version"], + stdout=subprocess.PIPE, + text=True, + ) + venv_version = result.stdout.split(" ")[1].strip().split(".") + return ( + venv_path + / "lib" + / f"python{venv_version[0]}.{venv_version[1]}" + / "site-packages" + ) + else: + return venv_path / "lib" / f"python{pyver[0]}.{pyver[1]}" / "site-packages" + + +def _initialize_black_env(upgrade=False): + if vim.eval("g:black_use_virtualenv ? 'true' : 'false'") == "false": + if upgrade: + print("Upgrade disabled due to g:black_use_virtualenv being disabled.") + print( + "Either use your system package manager (or pip) to upgrade black" + " separately," + ) + print("or modify your vimrc to have 'let g:black_use_virtualenv = 1'.") + return False + else: + # Nothing needed to be done. + return True + + pyver = sys.version_info[:3] + if pyver < (3, 10): + print("Sorry, Black requires Python 3.10+ to run.") + return False + + from pathlib import Path + import subprocess + import venv + + virtualenv_path = Path(vim.eval("g:black_virtualenv")).expanduser() + virtualenv_site_packages = str( + _get_virtualenv_site_packages(virtualenv_path, pyver) + ) + first_install = False + if not virtualenv_path.is_dir(): + print("Please wait, one time setup for Black.") + _executable = sys.executable + _base_executable = getattr(sys, "_base_executable", _executable) + try: + executable = str(_get_python_binary(Path(sys.exec_prefix), pyver)) + sys.executable = executable + sys._base_executable = executable + print(f"Creating a virtualenv in {virtualenv_path}...") + print( + "(this path can be customized in .vimrc by setting g:black_virtualenv)" + ) + venv.create(virtualenv_path, with_pip=True) + except Exception: + print( + "Encountered exception while creating virtualenv (see traceback below)." + ) + print(f"Removing {virtualenv_path}...") + import shutil + + shutil.rmtree(virtualenv_path) + raise + finally: + sys.executable = _executable + sys._base_executable = _base_executable + first_install = True + if first_install: + print("Installing Black with pip...") + if upgrade: + print("Upgrading Black with pip...") + if first_install or upgrade: + subprocess.run( + [str(_get_pip(virtualenv_path)), "install", "-U", "black"], + stdout=subprocess.PIPE, + ) + print("DONE! You are all set, thanks for waiting ✨ 🍰 ✨") + if first_install: + print( + "Pro-tip: to upgrade Black in the future, use the :BlackUpgrade command and" + " restart Vim.\n" + ) + if virtualenv_site_packages not in sys.path: + sys.path.insert(0, virtualenv_site_packages) + return True + + +if _initialize_black_env(): + try: + import black + except ImportError: + print(f"Could not import black from any of: {', '.join(sys.path)}.") + import time + + +def get_target_version(tv): + if isinstance(tv, black.TargetVersion): + return tv + ret = None + try: + ret = black.TargetVersion[tv.upper()] + except KeyError: + print( + f"WARNING: Target version {tv!r} not recognized by Black, using default" + " target" + ) + return ret + + +def Black(**kwargs): + """ + kwargs allows you to override ``target_versions`` argument of + ``black.FileMode``. + + ``target_version`` needs to be cleaned because ``black.FileMode`` + expects the ``target_versions`` argument to be a set of TargetVersion enums. + + Allow kwargs["target_version"] to be a string to allow + to type it more quickly. + + Using also target_version instead of target_versions to remain + consistent to Black's documentation of the structure of pyproject.toml. + """ + start = time.time() + configs = get_configs() + + black_kwargs = {} + if "target_version" in kwargs: + target_version = kwargs["target_version"] + + if not isinstance(target_version, (list, set)): + target_version = [target_version] + target_version = set( + filter(lambda x: x, map(lambda tv: get_target_version(tv), target_version)) + ) + black_kwargs["target_versions"] = target_version + + mode = black.FileMode( + line_length=configs["line_length"], + string_normalization=not configs["skip_string_normalization"], + is_pyi=vim.current.buffer.name.endswith(".pyi"), + magic_trailing_comma=not configs["skip_magic_trailing_comma"], + preview=configs["preview"], + **black_kwargs, + ) + quiet = configs["quiet"] + + buffer_str = "\n".join(vim.current.buffer) + "\n" + try: + new_buffer_str = black.format_file_contents( + buffer_str, + fast=configs["fast"], + mode=mode, + ) + except black.NothingChanged: + if not quiet: + print( + "Black: already well formatted, good job. (took" + f" {time.time() - start:.4f}s)" + ) + except Exception as exc: + print(f"Black: {exc}") + else: + current_buffer = vim.current.window.buffer + cursors = [] + for i, tabpage in enumerate(vim.tabpages): + if tabpage.valid: + for j, window in enumerate(tabpage.windows): + if window.valid and window.buffer == current_buffer: + cursors.append((i, j, window.cursor)) + vim.current.buffer[:] = new_buffer_str.split("\n")[:-1] + for i, j, cursor in cursors: + window = vim.tabpages[i].windows[j] + try: + window.cursor = cursor + except vim.error: + window.cursor = (len(window.buffer), 0) + if not quiet: + print(f"Black: reformatted in {time.time() - start:.4f}s.") + + +def get_configs(): + filename = vim.eval("@%") + path_pyproject_toml = black.find_pyproject_toml((filename,)) + if path_pyproject_toml: + toml_config = black.parse_pyproject_toml(path_pyproject_toml) + else: + toml_config = {} + + return { + flag.var_name: toml_config.get(flag.name, flag.cast(vim.eval(flag.vim_rc_name))) + for flag in FLAGS + } + + +def BlackUpgrade(): + _initialize_black_env(upgrade=True) + + +def BlackVersion(): + print(f"Black, version {black.__version__} on Python {sys.version}.") +EndPython3 + +function black#Black(...) + let kwargs = {} + for arg in a:000 + let arg_list = split(arg, '=') + let kwargs[arg_list[0]] = arg_list[1] + endfor +python3 << EOF +import vim + +kwargs = vim.eval("kwargs") +EOF + :py3 Black(**kwargs) +endfunction + +function black#BlackUpgrade() + :py3 BlackUpgrade() +endfunction + +function black#BlackVersion() + :py3 BlackVersion() +endfunction diff --git a/docs/Makefile b/docs/Makefile new file mode 100644 index 0000000..bb9d2f9 --- /dev/null +++ b/docs/Makefile @@ -0,0 +1,20 @@ +# Minimal makefile for Sphinx documentation +# + +# You can set these variables from the command line. +SPHINXOPTS = +SPHINXBUILD = sphinx-build +SPHINXPROJ = black +SOURCEDIR = . +BUILDDIR = _build + +# Put it first so that "make" without argument is like "make help". +help: + @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + +.PHONY: help Makefile + +# Catch-all target: route all unknown targets to Sphinx using the new +# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). +%: Makefile + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/docs/_static/license.svg b/docs/_static/license.svg new file mode 100644 index 0000000..25aa18b --- /dev/null +++ b/docs/_static/license.svg @@ -0,0 +1 @@ +licenselicenseMITMIT diff --git a/docs/_static/logo2-readme.png b/docs/_static/logo2-readme.png new file mode 100644 index 0000000..7704ec0 Binary files /dev/null and b/docs/_static/logo2-readme.png differ diff --git a/docs/_static/logo2.png b/docs/_static/logo2.png new file mode 100644 index 0000000..7c06e41 Binary files /dev/null and b/docs/_static/logo2.png differ diff --git a/docs/_static/pypi_template.svg b/docs/_static/pypi_template.svg new file mode 100644 index 0000000..0a0d2e9 --- /dev/null +++ b/docs/_static/pypi_template.svg @@ -0,0 +1 @@ +pypipypi$version$version diff --git a/docs/authors.md b/docs/authors.md new file mode 100644 index 0000000..21b0e1a --- /dev/null +++ b/docs/authors.md @@ -0,0 +1,3 @@ +```{include} ../AUTHORS.md + +``` diff --git a/docs/change_log.md b/docs/change_log.md new file mode 100644 index 0000000..e5f67e7 --- /dev/null +++ b/docs/change_log.md @@ -0,0 +1,3 @@ +```{include} ../CHANGES.md + +``` diff --git a/docs/compatible_configs/flake8/.flake8 b/docs/compatible_configs/flake8/.flake8 new file mode 100644 index 0000000..0d4ade3 --- /dev/null +++ b/docs/compatible_configs/flake8/.flake8 @@ -0,0 +1,3 @@ +[flake8] +max-line-length = 88 +extend-ignore = E203,E701 diff --git a/docs/compatible_configs/flake8/setup.cfg b/docs/compatible_configs/flake8/setup.cfg new file mode 100644 index 0000000..0d4ade3 --- /dev/null +++ b/docs/compatible_configs/flake8/setup.cfg @@ -0,0 +1,3 @@ +[flake8] +max-line-length = 88 +extend-ignore = E203,E701 diff --git a/docs/compatible_configs/flake8/tox.ini b/docs/compatible_configs/flake8/tox.ini new file mode 100644 index 0000000..0d4ade3 --- /dev/null +++ b/docs/compatible_configs/flake8/tox.ini @@ -0,0 +1,3 @@ +[flake8] +max-line-length = 88 +extend-ignore = E203,E701 diff --git a/docs/compatible_configs/isort/.editorconfig b/docs/compatible_configs/isort/.editorconfig new file mode 100644 index 0000000..edc849a --- /dev/null +++ b/docs/compatible_configs/isort/.editorconfig @@ -0,0 +1,2 @@ +[*.py] +profile = black diff --git a/docs/compatible_configs/isort/.isort.cfg b/docs/compatible_configs/isort/.isort.cfg new file mode 100644 index 0000000..f238bf7 --- /dev/null +++ b/docs/compatible_configs/isort/.isort.cfg @@ -0,0 +1,2 @@ +[settings] +profile = black diff --git a/docs/compatible_configs/isort/pyproject.toml b/docs/compatible_configs/isort/pyproject.toml new file mode 100644 index 0000000..2dc02c8 --- /dev/null +++ b/docs/compatible_configs/isort/pyproject.toml @@ -0,0 +1,2 @@ +[tool.isort] +profile = 'black' diff --git a/docs/compatible_configs/isort/setup.cfg b/docs/compatible_configs/isort/setup.cfg new file mode 100644 index 0000000..c76db01 --- /dev/null +++ b/docs/compatible_configs/isort/setup.cfg @@ -0,0 +1,2 @@ +[isort] +profile = black diff --git a/docs/compatible_configs/pycodestyle/.flake8 b/docs/compatible_configs/pycodestyle/.flake8 new file mode 100644 index 0000000..3422590 --- /dev/null +++ b/docs/compatible_configs/pycodestyle/.flake8 @@ -0,0 +1,3 @@ +[pycodestyle] +max-line-length = 88 +ignore = E203,E701 diff --git a/docs/compatible_configs/pycodestyle/setup.cfg b/docs/compatible_configs/pycodestyle/setup.cfg new file mode 100644 index 0000000..3422590 --- /dev/null +++ b/docs/compatible_configs/pycodestyle/setup.cfg @@ -0,0 +1,3 @@ +[pycodestyle] +max-line-length = 88 +ignore = E203,E701 diff --git a/docs/compatible_configs/pycodestyle/tox.ini b/docs/compatible_configs/pycodestyle/tox.ini new file mode 100644 index 0000000..3422590 --- /dev/null +++ b/docs/compatible_configs/pycodestyle/tox.ini @@ -0,0 +1,3 @@ +[pycodestyle] +max-line-length = 88 +ignore = E203,E701 diff --git a/docs/compatible_configs/pylint/pylintrc b/docs/compatible_configs/pylint/pylintrc new file mode 100644 index 0000000..e863488 --- /dev/null +++ b/docs/compatible_configs/pylint/pylintrc @@ -0,0 +1,2 @@ +[format] +max-line-length = 88 diff --git a/docs/compatible_configs/pylint/pyproject.toml b/docs/compatible_configs/pylint/pyproject.toml new file mode 100644 index 0000000..ef51f98 --- /dev/null +++ b/docs/compatible_configs/pylint/pyproject.toml @@ -0,0 +1,2 @@ +[tool.pylint.format] +max-line-length = "88" diff --git a/docs/compatible_configs/pylint/setup.cfg b/docs/compatible_configs/pylint/setup.cfg new file mode 100644 index 0000000..0b754cd --- /dev/null +++ b/docs/compatible_configs/pylint/setup.cfg @@ -0,0 +1,2 @@ +[pylint] +max-line-length = 88 diff --git a/docs/conf.py b/docs/conf.py new file mode 100644 index 0000000..414d8b7 --- /dev/null +++ b/docs/conf.py @@ -0,0 +1,235 @@ +# +# Configuration file for the Sphinx documentation builder. +# +# This file does only contain a selection of the most common options. For a +# full list see the documentation: +# https://www.sphinx-doc.org/en/master/usage/configuration.html + +# -- Path setup -------------------------------------------------------------- + +# If extensions (or modules to document with autodoc) are in another directory, +# add these directories to sys.path here. If the directory is relative to the +# documentation root, use os.path.abspath to make it absolute, like shown here. +# + +import os +import re +import string +from importlib.metadata import version +from pathlib import Path + +from sphinx.application import Sphinx + +CURRENT_DIR = Path(__file__).parent + + +def make_pypi_svg(version: str) -> None: + template: Path = CURRENT_DIR / "_static" / "pypi_template.svg" + target: Path = CURRENT_DIR / "_static" / "pypi.svg" + with open(str(template), encoding="utf8") as f: + svg: str = string.Template(f.read()).substitute(version=version) + with open(str(target), "w", encoding="utf8") as f: + f.write(svg) + + +def replace_pr_numbers_with_links(content: str) -> str: + """Replaces all PR numbers with the corresponding GitHub link.""" + return re.sub(r"#(\d+)", r"[#\1](https://github.com/psf/black/pull/\1)", content) + + +def handle_include_read( + app: Sphinx, + relative_path: Path, + parent_docname: str, + content: list[str], +) -> None: + """Handler for the include-read sphinx event.""" + if parent_docname == "change_log": + content[0] = replace_pr_numbers_with_links(content[0]) + + +def setup(app: Sphinx) -> None: + """Sets up a minimal sphinx extension.""" + app.connect("include-read", handle_include_read) + + +# Necessary so Click doesn't hit an encode error when called by +# sphinxcontrib-programoutput on Windows. +os.putenv("pythonioencoding", "utf-8") + +# -- Project information ----------------------------------------------------- + +project = "Black" +copyright = "2018-Present, Łukasz Langa and contributors to Black" +author = "Łukasz Langa and contributors to Black" + +# Autopopulate version +# The version, including alpha/beta/rc tags, but not commit hash and datestamps +release = version("black").split("+")[0] +# The short X.Y version. +version = release +for sp in "abcfr": + version = version.split(sp)[0] + +make_pypi_svg(release) + + +# -- General configuration --------------------------------------------------- + +# Add any Sphinx extension module names here, as strings. They can be +# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom +# ones. +extensions = [ + "sphinx.ext.autodoc", + "sphinx.ext.intersphinx", + "sphinx.ext.napoleon", + "myst_parser", + "sphinxcontrib.programoutput", + "sphinx_copybutton", +] + +# Add any paths that contain templates here, relative to this directory. +templates_path = ["_templates"] + +# The suffix(es) of source filenames. +# You can specify multiple suffix as a list of string: +source_suffix = [".rst", ".md"] + +# The master toctree document. +master_doc = "index" + +# The language for content autogenerated by Sphinx. Refer to documentation +# for a list of supported languages. +# +# This is also used if you do content translation via gettext catalogs. +# Usually you set "language" from the command line for these cases. +language = "en" + +# List of patterns, relative to source directory, that match files and +# directories to ignore when looking for source files. +# This pattern also affects html_static_path and html_extra_path . + +exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"] + +# The name of the Pygments (syntax highlighting) style to use. +pygments_style = "sphinx" + +# We need headers to be linkable to so ask MyST-Parser to autogenerate anchor IDs for +# headers up to and including level 3. +myst_heading_anchors = 3 + +# Prettier support formatting some MyST syntax but not all, so let's disable the +# unsupported yet still enabled by default ones. +myst_disable_syntax = [ + "colon_fence", + "myst_block_break", + "myst_line_comment", + "math_block", +] + +# Optional MyST Syntaxes +myst_enable_extensions = [] + +# -- Options for HTML output ------------------------------------------------- + +# The theme to use for HTML and HTML Help pages. See the documentation for +# a list of builtin themes. +# +html_theme = "furo" +html_logo = "_static/logo2-readme.png" + +# Add any paths that contain custom static files (such as style sheets) here, +# relative to this directory. They are copied after the builtin static files, +# so a file named "default.css" will overwrite the builtin "default.css". +html_static_path = ["_static"] + +# Custom sidebar templates, must be a dictionary that maps document names +# to template names. +# +# The default sidebars (for documents that don't match any pattern) are +# defined by theme itself. Builtin themes are using these templates by +# default: ``['localtoc.html', 'relations.html', 'sourcelink.html', +# 'searchbox.html']``. +# +# html_sidebars = {} + + +# -- Options for HTMLHelp output --------------------------------------------- + +# Output file base name for HTML help builder. +htmlhelp_basename = "blackdoc" + + +# -- Options for LaTeX output ------------------------------------------------ + +# Grouping the document tree into LaTeX files. List of tuples +# (source start file, target name, title, +# author, documentclass [howto, manual, or own class]). +latex_documents = [( + master_doc, + "black.tex", + "Documentation for Black", + "Łukasz Langa and contributors to Black", + "manual", +)] + + +# -- Options for manual page output ------------------------------------------ + +# One entry per manual page. List of tuples +# (source start file, name, description, authors, manual section). +man_pages = [(master_doc, "black", "Documentation for Black", [author], 1)] + + +# -- Options for Texinfo output ---------------------------------------------- + +# Grouping the document tree into Texinfo files. List of tuples +# (source start file, target name, title, author, +# dir menu entry, description, category) +texinfo_documents = [( + master_doc, + "Black", + "Documentation for Black", + author, + "Black", + "The uncompromising Python code formatter", + "Miscellaneous", +)] + + +# -- Options for Epub output ------------------------------------------------- + +# Bibliographic Dublin Core info. +epub_title = project +epub_author = author +epub_publisher = author +epub_copyright = copyright + +# The unique identifier of the text. This can be a ISBN number +# or the project homepage. +# +# epub_identifier = '' + +# A unique identification for the text. +# +# epub_uid = '' + +# A list of files that should not be packed into the epub file. +epub_exclude_files = ["search.html"] + + +# -- Extension configuration ------------------------------------------------- + +autodoc_member_order = "bysource" + +# -- sphinx-copybutton configuration ---------------------------------------- +copybutton_prompt_text = ( + r">>> |\.\.\. |> |\$ |\# | In \[\d*\]: | {2,5}\.\.\.: | {5,8}: " +) +copybutton_prompt_is_regexp = True +copybutton_remove_prompts = True + +# -- Options for intersphinx extension --------------------------------------- + +# Example configuration for intersphinx: refer to the Python standard library. +intersphinx_mapping = {"python": ("https://docs.python.org/3", None)} diff --git a/docs/contributing/gauging_changes.md b/docs/contributing/gauging_changes.md new file mode 100644 index 0000000..0af0c29 --- /dev/null +++ b/docs/contributing/gauging_changes.md @@ -0,0 +1,57 @@ +# Gauging changes + +A lot of the time, your change will affect formatting and/or performance. Quantifying +these changes is hard, so we have tooling to help make it easier. + +It's recommended you evaluate the quantifiable changes your _Black_ formatting +modification causes before submitting a PR. Think about if the change seems disruptive +enough to cause frustration to projects that are already "Black-formatted". + +## diff-shades + +diff-shades is a tool that runs _Black_ across a list of open-source projects recording +the results. The main highlight feature of diff-shades is being able to compare two +revisions of _Black_. This is incredibly useful as it allows us to see what exact +changes will occur, say merging a certain PR. + +For more information, please see the [diff-shades documentation][diff-shades]. + +### CI integration + +diff-shades is also the tool behind the "diff-shades results comparing ..." comments on +PRs. The project has a GitHub Actions workflow that analyzes and compares two revisions +of _Black_ according to these rules: + +| | Baseline revision | Target revision | +| --------------------- | ------------------------------- | ---------------------------- | +| On PRs | latest commit on PR base branch | PR commit with `main` merged | +| On pushes (main only) | latest PyPI version | the pushed commit | + +For pushes to main, there's only one analysis job named `preview-new-changes` where the +preview style is used for all projects. + +For PRs they get one more analysis job: `assert-no-changes`. It's similar to +`preview-new-changes` but runs with the stable code style. It will fail if changes were +made. This makes sure code won't be reformatted again and again within the same year in +accordance to Black's stability policy. + +Additionally for PRs, a PR comment will be posted embedding a summary previewing any +changes in both styles and links to further information. The next time the workflow is +triggered on the same PR, it'll update the pre-existing diff-shades comment. + +```{note} +Jobs will only fail intentionally if a file failed to format while analyzing, or if +changes were made to the stable style. Otherwise a failure indicates a bug in the +workflow. +``` + +The workflow uploads several artifacts upon completion: + +- HTML diffs (.html) + - handy for pushes where there's no PR to post a comment +- The raw analyses (.json) + - in case you want to do further analysis using the collected data locally +- `.preview.pr-comment.md` and `.stable.pr-comment.md` (if triggered by a PR) + - used to generate the PR comment and shouldn't be downloaded + +[diff-shades]: https://github.com/ichard26/diff-shades#readme diff --git a/docs/contributing/index.md b/docs/contributing/index.md new file mode 100644 index 0000000..f15afa3 --- /dev/null +++ b/docs/contributing/index.md @@ -0,0 +1,45 @@ +# Contributing + +```{toctree} +--- +hidden: +--- + +the_basics +gauging_changes +issue_triage +release_process +``` + +Welcome! Happy to see you willing to make the project better. Have you read the entire +[user documentation](https://black.readthedocs.io/en/latest/) yet? + +```{rubric} Bird's eye view + +``` + +In terms of inspiration, _Black_ is about as configurable as _gofmt_ (which is to say, +not very). This is deliberate. _Black_ aims to provide a consistent style and take away +opportunities for arguing about style. + +Bug reports and fixes are always welcome! Please follow the +[issue templates on GitHub](https://github.com/psf/black/issues/new/choose) for best +results. + +Before you suggest a new feature or configuration knob, ask yourself why you want it. If +it enables better integration with some workflow, fixes an inconsistency, speeds things +up, and so on - go for it! On the other hand, if your answer is "because I don't like a +particular formatting" then you're not ready to embrace _Black_ yet. Such changes are +unlikely to get accepted. You can still try but prepare to be disappointed. + +```{rubric} Contents + +``` + +This section covers the following topics: + +- {doc}`the_basics` +- {doc}`gauging_changes` +- {doc}`release_process` + +For an overview on contributing to the _Black_, please checkout {doc}`the_basics`. diff --git a/docs/contributing/issue_triage.md b/docs/contributing/issue_triage.md new file mode 100644 index 0000000..65cd1a9 --- /dev/null +++ b/docs/contributing/issue_triage.md @@ -0,0 +1,173 @@ +# Issue triage + +Currently, _Black_ uses the issue tracker for bugs, feature requests, proposed style +modifications, and general user support. Each of these issues have to be triaged so they +can be eventually be resolved somehow. This document outlines the triaging process and +also the current guidelines and recommendations. + +```{tip} +If you're looking for a way to contribute without submitting patches, this might be the +area for you. Since _Black_ is a popular project, its issue tracker is quite busy and +always needs more attention than is available. While triage isn't the most glamorous or +technically challenging form of contribution, it's still important. For example, we +would love to know whether that old bug report is still reproducible! + +You can get easily started by reading over this document and then responding to issues. + +If you contribute enough and have stayed for long enough, you may even be given +Triage permissions! +``` + +## The basics + +_Black_ gets a whole bunch of different issues, they range from bug reports to user +support issues. To triage is to identify, organize, and kickstart the issue's journey +through its lifecycle to resolution. + +More specifically, to triage an issue means to: + +- identify what type and categories the issue falls under +- confirm bugs +- ask questions / for further information if necessary +- link related issues +- provide the first initial feedback / support + +Note that triage is typically the first response to an issue, so don't fret if the issue +doesn't make much progress after initial triage. The main goal of triaging to prepare +the issue for future more specific development or discussion, so _eventually_ it will be +resolved. + +The lifecycle of a bug report or user support issue typically goes something like this: + +1. _the issue is waiting for triage_ +2. **identified** - has been marked with a type label and other relevant labels, more + details or a functional reproduction may be still needed (and therefore should be + marked with `S: needs repro` or `S: awaiting response`) +3. **confirmed** - the issue can reproduced and necessary details have been provided +4. **discussion** - initial triage has been done and now the general details on how the + issue should be best resolved are being hashed out +5. **awaiting fix** - no further discussion on the issue is necessary and a resolving PR + is the next step +6. **closed** - the issue has been resolved, reasons include: + - the issue couldn't be reproduced + - the issue has been fixed + - duplicate of another pre-existing issue or is invalid + +For enhancement, documentation, and style issues, the lifecycle looks very similar but +the details are different: + +1. _the issue is waiting for triage_ +2. **identified** - has been marked with a type label and other relevant labels +3. **discussion** - the merits of the suggested changes are currently being discussed, a + PR would be acceptable but would be at significant risk of being rejected +4. **accepted & awaiting PR** - it's been determined the suggested changes are OK and a + PR would be welcomed (`S: accepted`) +5. **closed**: - the issue has been resolved, reasons include: + - the suggested changes were implemented + - it was rejected (due to technical concerns, ethos conflicts, etc.) + - duplicate of a pre-existing issue or is invalid + +**Note**: documentation issues don't use the `S: accepted` label currently since they're +less likely to be rejected. + +## Labelling + +We use labels to organize, track progress, and help effectively divvy up work. + +Our labels are divided up into several groups identified by their prefix: + +- **T - Type**: the general flavor of issue / PR +- **C - Category**: areas of concerns, ranges from bug types to project maintenance +- **F - Formatting Area**: like C but for formatting specifically +- **S - Status**: what stage of resolution is this issue currently in? +- **R - Resolution**: how / why was the issue / PR resolved? + +We also have a few standalone labels: + +- **`good first issue`**: issues that are beginner-friendly (and will show up in GitHub + banners for first-time visitors to the repository) +- **`help wanted`**: complex issues that need and are looking for a fair bit of work as + to progress (will also show up in various GitHub pages) +- **`ci: skip news`**: for PRs that are trivial and don't need a CHANGELOG entry (and + skips the CHANGELOG entry check) +- **`ci: build all wheels`**: when a full wheel build is needed, such as to debug + platform-specific issues. Black does not build wheels for every platform on each pull + request because the full build matrix is expensive. After the label is added, the + workflow starts only when a new commit is pushed. + +```{note} +We do use labels for PRs, in particular the `ci: skip news` label, but we aren't that +rigorous about it. Just follow your judgement on what labels make sense for the specific +PR (if any even make sense). +``` + +## Projects + +For more general and broad goals we use projects to track work. Some may be long-term +projects with no true end (e.g. the "Amazing documentation" project) while others may be +more focused and have a definite end (like the "Getting to beta" project). + +```{note} +To modify GitHub Projects you need the +[Write repository permission level or higher](https://docs.github.com/en/organizations/managing-access-to-your-organizations-repositories/repository-permission-levels-for-an-organization#repository-access-for-each-permission-level). +``` + +## Closing issues + +Closing an issue signifies the issue has reached the end of its life, so closing issues +should be taken with care. The following is the general recommendation for each type of +issue. Note that these are only guidelines and if your judgement says something else +it's totally cool to go with it instead. + +For most issues, closing the issue manually or automatically after a resolving PR is +ideal. For bug reports specifically, if the bug has already been fixed, try to check in +with the issue opener that their specific case has been resolved before closing. Note +that we close issues as soon as they're fixed in the `main` branch. This doesn't +necessarily mean they've been released yet. + +Design and enhancement issues should be also closed when it's clear the proposed change +won't be implemented, whether that has been determined after a lot of discussion or just +simply goes against _Black_'s ethos. If such an issue turns heated, closing and locking +is acceptable if it's severe enough (although checking in with the core team is probably +a good idea). + +User support issues are best closed by the author or when it's clear the issue has been +resolved in some sort of manner. + +Duplicates and invalid issues should always be closed since they serve no purpose and +add noise to an already busy issue tracker. Although be careful to make sure it's truly +a duplicate and not just very similar before labelling and closing an issue as +duplicate. + +## Common reports + +Some issues are frequently opened, like issues about _Black_ formatted code causing E203 +messages. Even though these issues are probably heavily duplicated, they still require +triage sucking up valuable time from other things (although they usually skip most of +their lifecycle since they're closed on triage). + +Here's some of the most common issues and also pre-made responses you can use: + +### "The trailing comma isn't being removed by Black!" + +```text +Black used to remove the trailing comma if the expression fits in a single line, but this was changed by #826 and #1288. Now a trailing comma tells Black to always explode the expression. This change was made mostly for the cases where you _know_ a collection or whatever will grow in the future. Having it always exploded as one element per line reduces diff noise when adding elements. Before the "magic trailing comma" feature, you couldn't anticipate a collection's growth reliably since collections that fitted in one line were ruthlessly collapsed regardless of your intentions. One of Black's goals is reducing diff noise, so this was a good pragmatic change. + +So no, this is not a bug, but an intended feature. Anyway, [here's the documentation](https://github.com/psf/black/blob/master/docs/the_black_code_style.md#the-magic-trailing-comma) on the "magic trailing comma", including the ability to skip this functionality with the `--skip-magic-trailing-comma` option. Hopefully that helps solve the possible confusion. +``` + +### "Black formatted code is violating Flake8's E203!" + +```text +Hi, + +This is expected behaviour, please see the documentation regarding this case (emphasis mine): + +> PEP 8 recommends to treat : in slices as a binary operator with the lowest priority, and to leave an equal amount of space on either side, **except if a parameter is omitted (e.g. ham[1 + 1 :])**. It recommends no spaces around : operators for “simple expressions” (ham[lower:upper]), and **extra space for “complex expressions” (ham[lower : upper + offset])**. **Black treats anything more than variable names as “complex” (ham[lower : upper + 1]).** It also states that for extended slices, both : operators have to have the same amount of spacing, except if a parameter is omitted (ham[1 + 1 ::]). Black enforces these rules consistently. + +> This behaviour may raise E203 whitespace before ':' warnings in style guide enforcement tools like Flake8. **Since E203 is not PEP 8 compliant, you should tell Flake8 to ignore these warnings**. + +https://black.readthedocs.io/en/stable/the_black_code_style/current_style.html#slices + +Have a good day! +``` diff --git a/docs/contributing/release_process.md b/docs/contributing/release_process.md new file mode 100644 index 0000000..233d3cb --- /dev/null +++ b/docs/contributing/release_process.md @@ -0,0 +1,180 @@ +# Release process + +_Black_ has had a lot of work done into standardizing and automating its release +process. This document sets out to explain how everything works and how to release +_Black_ using said automation. + +## Release cadence + +**We aim to release whatever is on `main` every 1-2 months.** This ensures merged +improvements and bugfixes are shipped to users reasonably quickly, while not massively +fracturing the user-base with too many versions. This also keeps the workload on +maintainers consistent and predictable. + +If there's not much new on `main` to justify a release, it's acceptable to skip a +month's release. Ideally January releases should not be skipped because as per our +[stability policy](labels/stability-policy), the first release in a new calendar year +may make changes to the _stable_ style. While the policy applies to the first release +(instead of only January releases), confining changes to the stable style to January +will keep things predictable (and nicer) for users. + +Unless there is a serious regression or bug that requires immediate patching, **there +should not be more than one release per month**. While version numbers are cheap, +releases require a maintainer to both commit to do the actual cutting of a release, but +also to be able to deal with the potential fallout post-release. Releasing more +frequently than monthly nets rapidly diminishing returns. + +## Cutting a release + +**You must have `write` permissions for the _Black_ repository to cut a release.** + +The 10,000 foot view of the release process is that you prepare a release PR and then +publish a [GitHub Release]. This triggers [release automation](#release-workflows) that +builds all release artifacts and publishes them to the various platforms we publish to. + +We now have a `scripts/release.py` script to help with cutting the release PRs. + +- `python3 scripts/release.py --help` is your friend. + - `release.py` has only been tested in Python 3.12+ (so get with the times :D) + +To cut a release: + +1. Determine the release's version number + - **_Black_ follows the [CalVer] versioning standard using the `YY.M.N` format** + - So unless there already has been a release during this month, `N` should be `0` + - Example: the first release in January, 2026 → `26.1.0` + - `release.py` will calculate this and log it to stdout for your copy-paste pleasure +1. Double-check that no changelog entries since the last release were put in the wrong + section (e.g., run `git diff origin/stable CHANGES.md`) +1. File a PR editing `CHANGES.md` and the docs to version the latest changes + - Run `python3 scripts/release.py [--debug]` to generate most changes +1. If `release.py` fails manually edit; otherwise, yay, skip this step! + 1. Replace the `## Unreleased` header with the version number + 1. Remove any empty sections for the current release + 1. (_optional_) Read through and copy-edit the changelog (eg. by moving entries, + fixing typos, or rephrasing entries) +1. Update references to the latest version in + {doc}`/integrations/source_version_control` and + {doc}`/usage_and_configuration/the_basics` + - Example PR: [GH-4563] +1. Once the release PR is merged, wait until all CI passes + - If CI does not pass, **stop** and investigate the failure(s) as generally we'd want + to fix failing CI before cutting a release +1. [Draft a new GitHub Release][new-release] + 1. Click `Choose a tag` and type in the version number, then select the + `Create new tag: YY.M.N on publish` option that appears + 1. Verify that the new tag targets the `main` branch + 1. Make sure the release title is set to the version (`YY.M.N`), as otherwise the + default title is the last commit's title + 1. Copy and paste the _raw changelog Markdown_ for the current release into the + description box +1. Publish the GitHub Release, triggering [release automation](#release-workflows) that + will handle the rest +1. Once CI is done add + PR a new empty template for the next release to CHANGES.md + _(Template is able to be copy pasted from release.py should we fail)_ + 1. `python3 scripts/release.py --add-changes-template|-a [--debug]` + 1. Should that fail, please return to copy + paste +1. At this point, you're basically done. It's good practice to go and [watch and verify + that all the release workflows pass][black-actions], although you will receive a + GitHub notification should something fail. + - If something fails, don't panic. Please go read the respective workflow's logs and + configuration file to reverse-engineer your way to a fix/solution. + +Congratulations! You've successfully cut a new release of _Black_. Go and stand up and +take a break, you deserve it. + +```{important} +Once the release artifacts reach PyPI, you may see new issues being filed indicating +regressions. While regressions are not great, they don't automatically mean a hotfix +release is warranted. Unless the regressions are serious and impact many users, a hotfix +release is probably unnecessary. + +In the end, use your best judgement and ask other maintainers for their thoughts. +``` + +## Release workflows + +All of _Black_'s release automation uses [GitHub Actions]. All workflows are therefore +configured using YAML files in the `.github/workflows` directory of the _Black_ +repository. + +They are triggered by the publication of a [GitHub Release]. + +Below are descriptions of our release workflows. + +### build and publish + +This is our main workflow. It builds an [sdist] and [wheels] to upload to PyPI where the +vast majority of users will download Black from. It's divided into three job groups: + +#### sdist + pure wheel + +This single job builds the sdist and pure Python wheel (i.e., a wheel that only contains +Python code) using [Hatch]. These artifacts are general-purpose and can be used on +basically any platform supported by Python. + +#### generate wheels matrix / mypyc wheels (…) + +We use [mypyc] to compile _Black_ into a CPython C extension for significantly improved +performance. Wheels built with mypyc are platform and Python version specific. +[Supported platforms are documented in the FAQ](labels/mypyc-support). + +These matrix jobs use [cibuildwheel] which handles the complicated task of building C +extensions for many environments for us. Since building these wheels is slow, there are +multiple mypyc wheels jobs (hence the term "matrix") that build for a specific platform +(as noted in the job name in parentheses). + +#### publish-hatch / publish-mypyc + +These jobs upload the built sdist and all wheels to PyPI using [Trusted +publishing][trusted-publishing]. + +### publish binaries + +This workflow builds native executables for multiple platforms using [PyInstaller]. This +allows people to download the executable for their platform and run _Black_ without a +[Python runtime](https://wiki.python.org/moin/PythonImplementations) installed. + +The created binaries are stored on the associated GitHub Release for download over _IPv4 +only_ (GitHub still does not have IPv6 access 😢). + +### docker + +This workflow uses the QEMU powered `buildx` feature of Docker to upload an `arm64` and +`amd64`/`x86_64` build of the official _Black_ Docker image™. + +- _Currently this workflow uses an API Token associated with @cooperlees account_ + +```{note} +This also runs on each push to `main`. +``` + +### post release + +This workflow runs a few miscellaneous jobs related to repository maintenance. + +#### update-stable + +Updates the `stable` branch by force pushing it to the most recent tag. This saves us +from remembering to update the branch sometime after cutting the release. + +#### new-changelog + +Opens a new PR to add the "Unreleased" section back to the changelog. The PR is +intentionally not auto-merged, in case there's an issue and the release needs to be +re-cut. + +[black-actions]: https://github.com/psf/black/actions +[calver]: https://calver.org +[cibuildwheel]: https://cibuildwheel.readthedocs.io/ +[gh-4563]: https://github.com/psf/black/pull/4563 +[github actions]: https://github.com/features/actions +[github release]: https://github.com/psf/black/releases +[hatch]: https://hatch.pypa.io/latest/ +[mypyc]: https://mypyc.readthedocs.io/ +[new-release]: https://github.com/psf/black/releases/new +[pyinstaller]: https://www.pyinstaller.org/ +[sdist]: + https://packaging.python.org/en/latest/glossary/#term-source-distribution-or-sdist +[trusted-publishing]: https://docs.pypi.org/trusted-publishers/ +[wheels]: https://packaging.python.org/en/latest/glossary/#term-wheel diff --git a/docs/contributing/the_basics.md b/docs/contributing/the_basics.md new file mode 100644 index 0000000..c6e0c78 --- /dev/null +++ b/docs/contributing/the_basics.md @@ -0,0 +1,152 @@ +# The basics + +An overview on contributing to the _Black_ project. + +## Technicalities + +Development on the latest version of Python is preferred. You can use any operating +system. + +First clone the _Black_ repository: + +```console +$ git clone https://github.com/psf/black.git +$ cd black +``` + +Then install development dependencies inside a virtual environment of your choice, for +example: + +```console +$ python3 -m venv .venv +$ source .venv/bin/activate # activation for linux and mac +$ .venv\Scripts\activate # activation for windows + +(.venv)$ pip install --group dev +(.venv)$ pip install -e ".[d]" +(.venv)$ pre-commit install +``` + +Before submitting pull requests, run lints and tests with the following commands from +the root of the black repo: + +```console +(.venv)$ pre-commit run -a # Linting +(.venv)$ tox -e py # Unit tests +(.venv)$ tox -e fuzz # Optional Fuzz testing +(.venv)$ tox -e run_self # Format Black itself +``` + +### Development + +Further examples of invoking the tests + +```console +(.venv)$ tox --parallel=auto # Run all the above in parallel +(.venv)$ tox -e py314 # Run tests on a specific python version +(.venv)$ pytest -k # Run an individual test +(.venv)$ tox -e py -- --no-cov # Pass arguments to pytest +``` + +### Testing + +All aspects of the _Black_ style should be tested. Normally, tests should be created as +files in the `tests/data/cases` directory. These files consist of up to three parts: + +- A line that starts with `# flags: ` followed by a set of command-line options. For + example, if the line is `# flags: --preview --skip-magic-trailing-comma`, the test + case will be run with preview mode on and the magic trailing comma off. The options + accepted are mostly a subset of those of _Black_ itself, except for the + `--minimum-version=` flag, which should be used when testing a grammar feature that + works only in newer versions of Python. This flag ensures that we don't try to + validate the AST on older versions and tests that we autodetect the Python version + correctly when the feature is used. For the exact flags accepted, see the function + `get_flags_parser` in `tests/util.py`. If this line is omitted, the default options + are used. +- A block of Python code used as input for the formatter. +- The line `# output`, followed by the output of _Black_ when run on the previous block. + If this is omitted, the test asserts that _Black_ will leave the input code unchanged. + +_Black_ has two pytest command-line options affecting test files in `tests/data/` that +are split into an input part, and an output part, separated by a line with `# output`. +These can be passed to `pytest` through `tox`, or directly into pytest if not using +`tox`. + +#### `--print-full-tree` + +Upon a failing test, print the full concrete syntax tree (CST) as it is after processing +the input ("actual"), and the tree that's yielded after parsing the output ("expected"). +Note that a test can fail with different output with the same CST. This used to be the +default, but now defaults to `False`. + +```console +(.venv)$ tox -e py -- --print-full-tree +``` + +#### `--print-tree-diff` + +Upon a failing test, print the diff of the trees as described above. This is the +default. To turn it off pass `--print-tree-diff=False`. + +```console +(.venv)$ tox -e py -- --print-tree-diff=False +``` + +### News / Changelog Requirement + +`Black` has CI that will check for an entry corresponding to your PR in `CHANGES.md`. If +you feel this PR does not require a changelog entry please state that in a comment and a +maintainer can add a `ci: skip news` label to make the CI pass. Otherwise, please ensure +you have a line in the following format added below the appropriate header: + +```md +- `Black` is now more awesome (#X) +``` + + + +Note that X should be your PR number, not issue number! To workout X, please use +Next PR +Number. This is not perfect but saves a lot of release overhead as now the releaser +does not need to go back and workout what to add to the `CHANGES.md` for each release. + +### Style Changes + +Please familiarize yourself with our [stability policy](labels/stability-policy). +Therefore, most style changes must be added to the `--preview` style. Exceptions are +fixing crashes or changes that would not affect an already-formatted file. + +If a change would affect the advertised code style, please modify the documentation (The +_Black_ code style) to reflect that change. Patches that fix unintended bugs in +formatting don't need to be mentioned separately. + +If the change is implemented with the `--preview` flag, please include the change in the +Future Style document instead and write the changelog entry under the dedicated "Preview +style" heading. + +### Docs Testing + +If you make changes to docs, you can test they still build locally too. + +```console +(.venv)$ pip install --group docs +(.venv)$ pip install -e ".[d]" +(.venv)$ sphinx-build -a -b html -W docs/ docs/_build/ +``` + +## Hygiene + +If you're fixing a bug, add a test. Run it first to confirm it fails, then fix the bug, +and run the test again to confirm it's really fixed. + +If adding a new feature, add a test. In fact, always add a test. If adding a large +feature, please first open an issue to discuss it beforehand. + +## Finally + +Thanks again for your interest in improving the project! You're taking action when most +people decide to sit and watch. diff --git a/docs/faq.md b/docs/faq.md new file mode 100644 index 0000000..ab2b173 --- /dev/null +++ b/docs/faq.md @@ -0,0 +1,139 @@ +# Frequently Asked Questions + +The most common questions and issues users face are aggregated to this FAQ. + +```{contents} +:local: +:backlinks: none +:class: this-will-duplicate-information-and-it-is-still-useful-here +``` + +## Why spaces? I prefer tabs + +PEP 8 recommends spaces over tabs, and they are used by most of the Python community. +_Black_ provides no options to configure the indentation style, and requests for such +options will not be considered. + +However, we recognise that using tabs is an accessibility issue as well. While the +option will never be added to _Black_, visually impaired developers may find conversion +tools such as `expand/unexpand` (for Linux) useful when contributing to Python projects. +A workflow might consist of e.g. setting up appropriate pre-commit and post-merge git +hooks, and scripting `unexpand` to run after applying _Black_. + +## Does Black have an API? + +Not yet. _Black_ is fundamentally a command line tool. Many +[integrations](/integrations/index.md) are provided, but a Python interface is not one +of them. A simple API is being [planned](https://github.com/psf/black/issues/779) +though. + +## Is Black safe to use? + +Yes. _Black_ is strictly about formatting, nothing else. Black strives to ensure that +after formatting the AST is +[checked](the_black_code_style/current_style.md#ast-before-and-after-formatting) with +limited special cases where the code is allowed to differ. If issues are found, an error +is raised and the file is left untouched. Magical comments that influence linters and +other tools, such as `# noqa`, may be moved by _Black_. See below for more details. + +## How stable is Black's style? + +Stable. _Black_ aims to enforce one style and one style only, with some room for +pragmatism. See [The Black Code Style](the_black_code_style/index.md) for more details. + +Starting in 2022, the formatting output is stable for the releases made in the same year +(other than unintentional bugs). At the beginning of every year, the first release will +make changes to the stable style. It is possible to opt in to the latest formatting +styles using the `--preview` flag. + +## Why is my file not formatted? + +Most likely because it is ignored in `.gitignore` or excluded with configuration. See +[file collection and discovery](usage_and_configuration/file_collection_and_discovery.md) +for details. + +## Why is my Jupyter Notebook cell not formatted? + +_Black_ is timid about formatting Jupyter Notebooks. Cells containing any of the +following will not be formatted: + +- automagics (e.g. `pip install black`) +- non-Python cell magics (e.g. `%%writefile`) +- multiline magics +- code which `IPython`'s `TransformerManager` would transform magics into +- invalid syntax + +See +[Using _Black_ with Jupyter Notebooks](guides/using_black_with_jupyter_notebooks.md#cells-that-black-will-skip) +for details. + +## Why does Flake8 report warnings? + +Some of Flake8's rules conflict with Black's style. We recommend disabling these rules. +See [Using _Black_ with other tools](labels/why-pycodestyle-warnings). + +## Which Python versions does Black support? + +_Black_ generally supports all Python versions supported by CPython (see +[the Python devguide](https://devguide.python.org/versions/) for current information). +We promise to support at least all Python versions that have not reached their end of +life. This is the case for both running _Black_ and formatting code. + +Support for formatting Python 2 code was removed in version 22.0. While we've made no +plans to stop supporting older Python 3 minor versions immediately, their support might +also be removed some time in the future without a deprecation period. + +`await`/`async` as soft keywords/identifiers are no longer supported as of 25.9.0. + +Runtime support for 3.6 was removed in version 22.10.0, for 3.7 in version 23.7.0, for +3.8 in version 24.10.0, and for 3.9 in version 25.12.0. + +## Why does my linter or typechecker complain after I format my code? + +Some linters and other tools use magical comments (e.g., `# noqa`, `# type: ignore`) to +influence their behavior. While Black does its best to recognize such comments and leave +them in the right place, this detection is not and cannot be perfect. Therefore, you'll +sometimes have to manually move these comments to the right place after you format your +codebase with _Black_. + +## Can I run Black with PyPy? + +Yes, there is support for PyPy 3.8 and higher. + +## Why does Black not detect syntax errors in my code? + +_Black_ is an autoformatter, not a Python linter or interpreter. Detecting all syntax +errors is not a goal. It can format all code accepted by CPython (if you find an example +where that doesn't hold, please report a bug!), but it may also format some code that +CPython doesn't accept. + +(labels/mypyc-support)= + +## What is `compiled: yes/no` all about in the version output? + +While _Black_ is indeed a pure Python project, we use [mypyc] to compile _Black_ into a +C Python extension, usually doubling performance. These compiled wheels are available +for 64-bit versions of Windows (both AMD and ARM), Linux (via the manylinux standard), +and macOS across all supported CPython versions. + +Platforms including musl-based and/or ARM Linux distributions are currently **not** +supported. These platforms will fall back to the slower pure Python wheel available on +PyPI. + +If you are experiencing exceptionally weird issues or even segfaults, you can try +passing `--no-binary black` to your pip install invocation. This flag excludes all +wheels (including the pure Python wheel), so this command will use the [sdist]. + +[mypyc]: https://mypyc.readthedocs.io/en/stable/ +[sdist]: + https://packaging.python.org/en/latest/glossary/#term-Source-Distribution-or-sdist + +## Why are emoji not displaying correctly on Windows? + +When using Windows, the emoji in _Black_'s output may not display correctly. This is not +fixable from _Black_'s end. + +Instead, run your chosen command line/shell through [Windows Terminal], which will +properly handle rendering the emoji. + +[Windows Terminal]: https://aka.ms/terminal diff --git a/docs/getting_started.md b/docs/getting_started.md new file mode 100644 index 0000000..5c80b6f --- /dev/null +++ b/docs/getting_started.md @@ -0,0 +1,62 @@ +# Getting Started + +New to _Black_? Don't worry, you've found the perfect place to get started! + +## Do you like the _Black_ code style? + +Before using _Black_ on some of your code, it might be a good idea to first understand +how _Black_ will format your code. _Black_ isn't for everyone and you may find something +that is a dealbreaker for you personally, which is okay! The current _Black_ code style +[is described here](./the_black_code_style/current_style.md). + +## Try it out quickly + +If you want a quick taste of _Black_ without creating a file first, format a snippet +from the command line: + +```sh +black --code "x = { 'a':1,'b':2 }" +``` + +## Installation + +_Black_ can be installed by running `pip install black`. It requires Python 3.10+ to +run. + +If you use pipx, you can install Black with `pipx install black`. + +If you want to format Jupyter Notebooks, install with `pip install "black[jupyter]"`. +See the [Jupyter Notebooks guide](./guides/using_black_with_jupyter_notebooks.md) for +more details. + +If you want to run _Black_ without installing Python, download one of the +PyInstaller-built standalone executables from the +[latest GitHub release](https://github.com/psf/black/releases/latest). + +If you can't wait for the latest _hotness_ and want to install from GitHub, use: + +`pip install git+https://github.com/psf/black` + +## Basic usage + +To get started right away with sensible defaults: + +```sh +black {source_file_or_directory}... +``` + +You can run _Black_ as a package if running it as a script doesn't work: + +```sh +python -m black {source_file_or_directory}... +``` + +## Next steps + +Took a look at [the _Black_ code style](./the_black_code_style/current_style.md) and +tried out _Black_? Fantastic, you're ready for more. Why not explore some more on using +_Black_ by reading +[Usage and Configuration: The basics](./usage_and_configuration/the_basics.md). +Alternatively, you can check out the +[Introducing _Black_ to your project](./guides/introducing_black_to_your_project.md) +guide. diff --git a/docs/guides/index.md b/docs/guides/index.md new file mode 100644 index 0000000..83a3f36 --- /dev/null +++ b/docs/guides/index.md @@ -0,0 +1,18 @@ +# Guides + +```{toctree} +--- +hidden: +--- + +introducing_black_to_your_project +using_black_with_other_tools +using_black_with_jupyter_notebooks +``` + +Wondering how to do something specific? You've found the right place! Listed below are +topic specific guides available: + +- {doc}`introducing_black_to_your_project` +- {doc}`using_black_with_other_tools` +- {doc}`using_black_with_jupyter_notebooks` diff --git a/docs/guides/introducing_black_to_your_project.md b/docs/guides/introducing_black_to_your_project.md new file mode 100644 index 0000000..5c9b47c --- /dev/null +++ b/docs/guides/introducing_black_to_your_project.md @@ -0,0 +1,52 @@ +# Introducing _Black_ to your project + +```{note} +This guide is incomplete. Contributions are welcomed and would be deeply appreciated! +``` + +## Avoiding ruining git blame + +A long-standing argument against moving to automated code formatters like _Black_ is +that the migration will clutter up the output of `git blame`. This was a valid argument, +but since Git version 2.23, Git natively supports +[ignoring revisions in blame](https://git-scm.com/docs/git-blame#Documentation/git-blame.txt---ignore-revltrevgt) +with the `--ignore-rev` option. You can also pass a file listing the revisions to ignore +using the `--ignore-revs-file` option. The changes made by the revision will be ignored +when assigning blame. Lines modified by an ignored revision will be blamed on the +previous revision that modified those lines. + +So when migrating your project's code style to _Black_, reformat everything and commit +the changes (preferably in one massive commit). Then put the full 40 characters commit +identifier(s) into a file usually called `.git-blame-ignore-revs` at the root of your +project directory. + +```text +# Migrate code style to Black +5b4ab991dede475d393e9d69ec388fd6bd949699 +``` + +Afterwards, you can pass that file to `git blame` and see clean and meaningful blame +information. + +```console +$ git blame important.py --ignore-revs-file .git-blame-ignore-revs +7a1ae265 (John Smith 2019-04-15 15:55:13 -0400 1) def very_important_function(text, file): +abdfd8b0 (Alice Doe 2019-09-23 11:39:32 -0400 2) text = text.lstrip() +7a1ae265 (John Smith 2019-04-15 15:55:13 -0400 3) with open(file, "r+") as f: +7a1ae265 (John Smith 2019-04-15 15:55:13 -0400 4) f.write(formatted) +``` + +You can even configure `git` to automatically ignore revisions listed in a file on every +call to `git blame`. + +```console +$ git config blame.ignoreRevsFile .git-blame-ignore-revs +``` + +**The one caveat is that some online Git-repositories do not yet support ignoring +revisions using their native blame UI.** So blame information will be cluttered with a +reformatting commit on those platforms. However, +[GitHub](https://docs.github.com/en/repositories/working-with-files/using-files/viewing-a-file#ignore-commits-in-the-blame-view) +and +[GitLab (since version 17.10)](https://about.gitlab.com/releases/2025/03/20/gitlab-17-10-released/#ignore-specific-revisions-in-git-blame) +both support `.git-blame-ignore-revs` in blame views by default. diff --git a/docs/guides/using_black_with_jupyter_notebooks.md b/docs/guides/using_black_with_jupyter_notebooks.md new file mode 100644 index 0000000..1743f0b --- /dev/null +++ b/docs/guides/using_black_with_jupyter_notebooks.md @@ -0,0 +1,134 @@ +# Using _Black_ with Jupyter Notebooks + +_Black_ supports formatting Jupyter Notebooks (`.ipynb` files) natively. + +## Installation + +To format Jupyter Notebooks, install _Black_ with the `jupyter` extra: + +```sh +pip install "black[jupyter]" +``` + +```{note} +Without the `jupyter` extra, _Black_ will not be able to format `.ipynb` files. +``` + +## Basic usage + +Once installed, you can format notebooks the same way you format Python files: + +```sh +black notebook.ipynb +``` + +You can also format entire directories containing a mix of `.py` and `.ipynb` files: + +```sh +black . +``` + +_Black_ will automatically detect Jupyter Notebooks by their `.ipynb` extension and +format them accordingly. + +### Formatting via standard input + +If you're piping notebook content on standard input, use the `--ipynb` flag to tell +_Black_ to treat the input as a Jupyter Notebook: + +```sh +cat notebook.ipynb | black --ipynb - +``` + +## What is (and isn't) formatted + +_Black_ formats the Python code cells in your notebook while preserving: + +- Markdown cells +- Cell outputs +- Cell metadata +- Notebook metadata + +Only the source code within Python code cells is reformatted. + +### Cells that _Black_ will skip + +_Black_ is cautious about formatting notebook cells. The following cells will **not** be +formatted: + +- **Automagics** — e.g. `pip install black` (without the `%` prefix) +- **Non-Python cell magics** — e.g.: + ```python + %%writefile script.py + print("hello") + ``` +- **Multiline magics** — e.g.: + ```python + %timeit f(1, \ + 2, \ + 3) + ``` +- **IPython internal calls** — code that `IPython`'s `TransformerManager` would + transform, e.g.: + ```python + get_ipython().system('ls') + ``` +- **Invalid syntax** — as it cannot be safely distinguished from automagics without a + running IPython kernel. + +If you notice a cell is not being formatted, it is likely because it contains one of the +above constructs. + +Additionally, _Black_ cannot format Jupyter Notebooks with the `--line-ranges` option. + +### Cell magics + +_Black_ understands IPython magics, but is conservative about which cells it will +format. By default, _Black_ recognizes standard IPython magics. + +#### Custom python cell magics + +If you use custom cell magics that contain Python code, you can tell _Black_ about them +using the `--python-cell-magics` flag: + +```sh +black --python-cell-magics writefile notebook.ipynb +``` + +This also works in `pyproject.toml`: + +```toml +[tool.black] +python-cell-magics = ["writefile", "my_custom_magic"] +``` + +## Integrations + +### pre-commit + +Simply replace the `black` hook with `black-jupyter`. + +```yaml +repos: + - repo: https://github.com/psf/black-pre-commit-mirror + rev: 26.5.1 + hooks: + - id: black-jupyter + language_version: python3.11 +``` + +See the [source version control integration](../integrations/source_version_control.md) +docs for more examples of using Black with pre-commit. + +### GitHub Actions + +Set the `jupyter` option to `true`. + +```yaml +- uses: psf/black@stable + with: + jupyter: true +``` + +See the [GitHub Actions integration](../integrations/source_version_control.md) docs for +more examples of using Black with GitHub Actions. diff --git a/docs/guides/using_black_with_other_tools.md b/docs/guides/using_black_with_other_tools.md new file mode 100644 index 0000000..22c6430 --- /dev/null +++ b/docs/guides/using_black_with_other_tools.md @@ -0,0 +1,303 @@ +# Using _Black_ with other tools + +## Black compatible configurations + +All of Black's changes are harmless (or at least, they should be), but a few do conflict +against other tools. It is not uncommon to be using other tools alongside _Black_ like +linters and type checkers. Some of them need a bit of tweaking to resolve the conflicts. +Listed below are _Black_ compatible configurations in various formats for the common +tools out there. + +**Please note** that _Black_ only supports the TOML file format for its configuration +(e.g. `pyproject.toml`). The provided examples are to only configure their corresponding +tools, using **their** supported file formats. + +Compatible configuration files can be +[found here](https://github.com/psf/black/blob/main/docs/compatible_configs/). + +### isort + +[isort](https://isort.readthedocs.io/) helps to sort and format imports in your Python +code. _Black_ also formats imports, but in a different way from isort's defaults which +leads to conflicting changes. + +#### Profile + +Since version 5.0.0, isort supports +[profiles](https://isort.readthedocs.io/en/latest/configuration/profiles.html) to allow +easy interoperability with common code styles. You can set the black profile in any of +the +[config files](https://isort.readthedocs.io/en/latest/configuration/config_files.html) +supported by isort. Below, an example for `pyproject.toml`: + +```toml +[tool.isort] +profile = "black" +``` + +#### Custom Configuration + +If you're using an isort version that is older than 5.0.0 or you have some custom +configuration for _Black_, you can tweak your isort configuration to make it compatible +with _Black_. Below, an example for `.isort.cfg`: + +```ini +multi_line_output = 3 +include_trailing_comma = True +force_grid_wrap = 0 +use_parentheses = True +ensure_newline_before_comments = True +line_length = 88 +``` + +#### Why those options above? + +_Black_ wraps imports that surpass `line-length` by moving identifiers onto separate +lines and by adding a trailing comma after each. A more detailed explanation of this +behaviour can be +[found here](../the_black_code_style/current_style.md#how-black-wraps-lines). + +isort's default mode of wrapping imports that extend past the `line_length` limit is +"Grid". + +```python +from third_party import (lib1, lib2, lib3, + lib4, lib5, ...) +``` + +This style is incompatible with _Black_, but isort can be configured to use a different +wrapping mode called "Vertical Hanging Indent" which looks like this: + +```python +from third_party import ( + lib1, + lib2, + lib3, + lib4, +) +``` + +This style is _Black_ compatible and can be achieved by `multi-line-output = 3`. Also, +as mentioned above, when wrapping long imports _Black_ puts a trailing comma and uses +parentheses. isort should follow the same behaviour and passing the options +`include_trailing_comma = True` and `use_parentheses = True` configures that. + +The option `force_grid_wrap = 0` is just to tell isort to only wrap imports that surpass +the `line_length` limit. + +Finally, isort should be told to wrap imports when they surpass _Black_'s default limit +of 88 characters via `line_length = 88` as well as +`ensure_newline_before_comments = True` to ensure spacing import sections with comments +works the same as with _Black_. + +**Please note** `ensure_newline_before_comments = True` only works since isort >= 5 but +does not break older versions so you can keep it if you are running previous versions. + +#### Formats + +
+.isort.cfg + +```ini +[settings] +profile = black +``` + +
+ +
+setup.cfg + +```ini +[isort] +profile = black +``` + +
+ +
+pyproject.toml + +```toml +[tool.isort] +profile = 'black' +``` + +
+ +
+.editorconfig + +```ini +[*.py] +profile = black +``` + +
+ +### pycodestyle + +[pycodestyle](https://pycodestyle.pycqa.org/en/stable/) is a code linter. It warns you +of syntax errors, possible bugs, stylistic errors, etc. For the most part, pycodestyle +follows [PEP 8](https://peps.python.org/pep-0008/) when warning about stylistic errors. +There are a few deviations that cause incompatibilities with _Black_. + +#### Configuration + +```ini +max-line-length = 88 +ignore = E203,E701 +``` + +(labels/why-pycodestyle-warnings)= + +#### Why those options above? + +##### `max-line-length` + +As with isort, pycodestyle should be configured to allow lines up to the length limit of +`88`, _Black_'s default. + +##### `E203` + +In some cases, as determined by PEP 8, _Black_ will enforce an equal amount of +whitespace around slice operators. Due to this, pycodestyle will raise +`E203 whitespace before ':'` warnings. Since this warning is not PEP 8 compliant, it +should be disabled. + +##### `E701` / `E704` + +_Black_ will collapse implementations of classes and functions consisting solely of `..` +to a single line. This matches how such examples are formatted in PEP 8. It remains true +that in all other cases Black will prevent multiple statements on the same line, in +accordance with PEP 8 generally discouraging this. + +However, `pycodestyle` does not mirror this logic and may raise +`E701 multiple statements on one line (colon)` in this situation. Its +disabled-by-default `E704 multiple statements on one line (def)` rule may also raise +warnings and should not be enabled. + +##### `W503` + +When breaking a line, _Black_ will break it before a binary operator. This is compliant +with PEP 8 as of +[April 2016](https://github.com/python/peps/commit/c59c4376ad233a62ca4b3a6060c81368bd21e85b#diff-64ec08cc46db7540f18f2af46037f599). +There's a disabled-by-default warning in Flake8 which goes against this PEP 8 +recommendation called `W503 line break before binary operator`. It should not be enabled +in your configuration. You can use its counterpart +`W504 line break after binary operator` instead. + +#### Formats + +
+setup.cfg, .pycodestyle, tox.ini + +```ini +[pycodestyle] +max-line-length = 88 +ignore = E203,E701 +``` + +
+ +### Flake8 + +[Flake8](https://flake8.pycqa.org/en/stable/) is a wrapper around multiple linters, +including pycodestyle. As such, it has many of the same issues. + +#### Bugbear + +It's recommended to use [the Bugbear plugin](https://github.com/PyCQA/flake8-bugbear) +and enable +[its B950 check](https://github.com/PyCQA/flake8-bugbear#opinionated-warnings#:~:text=you%20expect%20it.-,B950,-%3A%20Line%20too%20long) +instead of using Flake8's E501, because it aligns with +[Black's 10% rule](labels/line-length). + +Install Bugbear and use the following config: + +```ini +[flake8] +max-line-length = 80 +extend-select = B950 +extend-ignore = E203,E501,E701 +``` + +#### Minimal Configuration + +In cases where you can't or don't want to install Bugbear, you can use this minimally +compatible config: + +```ini +[flake8] +max-line-length = 88 +extend-ignore = E203,E701 +``` + +#### Why those options above? + +See [the pycodestyle section](labels/why-pycodestyle-warnings) above. + +#### Formats + +
+.flake8, setup.cfg, tox.ini + +```ini +[flake8] +max-line-length = 88 +extend-ignore = E203,E701 +``` + +
+ +### Pylint + +[Pylint](https://pylint.readthedocs.io/) is also a code linter like Flake8. It has many +of the same checks as Flake8 and more. It particularly has more formatting checks +regarding style conventions like variable naming. + +#### Configuration + +```ini +max-line-length = 88 +``` + +#### Why those options above? + +Pylint should be configured to only complain about lines that surpass `88` characters +via `max-line-length = 88`. + +If using `pylint<2.6.0`, also disable `C0326` and `C0330` as these are incompatible with +_Black_ formatting and have since been removed. + +#### Formats + +
+pylintrc + +```ini +[format] +max-line-length = 88 +``` + +
+ +
+setup.cfg + +```ini +[pylint] +max-line-length = 88 +``` + +
+ +
+pyproject.toml + +```toml +[tool.pylint.format] +max-line-length = "88" +``` + +
diff --git a/docs/index.md b/docs/index.md new file mode 100644 index 0000000..e27a50b --- /dev/null +++ b/docs/index.md @@ -0,0 +1,136 @@ + + +# The uncompromising code formatter + +> “Any color you like.” + +By using _Black_, you agree to cede control over minutiae of hand-formatting. In return, +_Black_ gives you speed, determinism, and freedom from `pycodestyle` nagging about +formatting. You will save time and mental energy for more important matters. + +_Black_ makes code review faster by producing the smallest diffs possible. Blackened +code looks the same regardless of the project you're reading. Formatting becomes +transparent after a while and you can focus on the content instead. + +```{admonition} Note - Black is now stable! +_Black_ is [successfully used](https://github.com/psf/black#used-by) by many projects, +small and big. _Black_ has a comprehensive test suite, with efficient parallel tests, +our own auto formatting and parallel Continuous Integration runner. Now that we have +become stable, you should not expect large changes to formatting in the future. +Stylistic changes will mostly be responses to bug reports and support for new Python +syntax. + +Also, as a safety measure which slows down processing, _Black_ will check that the +reformatted code still produces a valid AST that is effectively equivalent to the +original (see the [Pragmatism](./the_black_code_style/current_style.md#pragmatism) +section for details). If you're feeling confident, use `--fast`. +``` + +```{note} +{doc}`Black is licensed under the MIT license `. +``` + +## Testimonials + +**Mike Bayer**, creator of [`SQLAlchemy`](https://www.sqlalchemy.org/): + +> _I can't think of any single tool in my entire programming career that has given me a +> bigger productivity increase by its introduction. I can now do refactorings in about +> 1% of the keystrokes that it would have taken me previously when we had no way for +> code to format itself._ + +**Dusty Phillips**, +[writer](https://www.amazon.com/stores/Dusty-Phillips/author/B00HSYG5BO): + +> _Black is opinionated so you don't have to be._ + +**Hynek Schlawack**, creator of [`attrs`](https://www.attrs.org/), core developer of +Twisted and CPython: + +> _An auto-formatter that doesn't suck is all I want for Xmas!_ + +**Carl Meyer**, [Django](https://www.djangoproject.com/) core developer: + +> _At least the name is good._ + +**Kenneth Reitz**, creator of [`requests`](https://requests.readthedocs.io/en/stable/) +and [pipenv](https://pipenv.pypa.io/en/stable/): + +> _This vastly improves the formatting of our code. Thanks a ton!_ + +## Show your style + +Use the badge in your project's README.md: + +```md +[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black) +``` + +Using the badge in README.rst: + +```rst +.. image:: https://img.shields.io/badge/code%20style-black-000000.svg + :target: https://github.com/psf/black +``` + +Looks like this: + +```{image} https://img.shields.io/badge/code%20style-black-000000.svg +:target: https://github.com/psf/black +``` + +## Contents + +```{toctree} +--- +maxdepth: 3 +includehidden: +--- + +the_black_code_style/index +``` + +```{toctree} +--- +maxdepth: 3 +includehidden: +caption: User Guide +--- + +getting_started +usage_and_configuration/index +integrations/index +guides/index +faq +``` + +```{toctree} +--- +maxdepth: 2 +includehidden: +caption: Development +--- + +contributing/index +change_log +authors +``` + +```{toctree} +--- +hidden: +caption: Project Links +--- + +GitHub +PyPI +Chat +``` + +# Indices and tables + +- {ref}`genindex` +- {ref}`search` diff --git a/docs/integrations/doctest_formatting.md b/docs/integrations/doctest_formatting.md new file mode 100644 index 0000000..36681dd --- /dev/null +++ b/docs/integrations/doctest_formatting.md @@ -0,0 +1,102 @@ +# Doctest Formatting + +While _Black_ makes some decisions about styling for docstrings, it does not make any +assumptions about the contents of documentation. Thus, executable Python code inside +docstrings or documentation files (e.g. doctests), will not be formatted by _Black_. + +Listed below are tools that apply _Black_ formatting to code inside docstrings and +documentation files. + +> Note: There are some observed inconsistencies between the below packages. Because of +> this, we hesitate to make any recommendations. Any installed packages are installed at +> your own risk. We also encourage anyone to contribute documentation for additional +> packages that apply _Black_ formatting to doctests. + +## blacken-docs + +[`blacken-docs`](https://github.com/adamchainz/blacken-docs) is primarily used to apply +_Black_ formatting to code in documentation files (e.g. `.rst`, `.md`, `.tex`). + +`blacken-docs` supports the following: + +- Python code blocks in Markdown, reStructuredText, and LaTeX files. Similar to + `blackdoc`, normal _Black_ formatting is applied, so doctests inside Python code + blocks will not be formatted. + + ````md + ```python + print("Hello world!") + ``` + ```` + + ```rst + .. code-block:: python + print("Hello world!") + ``` + + ```latex + \begin{minted}{python} + print("Hello world!") + \end{minted} + ``` + +- Doctests inside Pycon code blocks in Markdown and reStructuredText. The code blocks + may be included in a `.md` or `.rst` file, or inside a docstring in a Python file. + + ````md + ```python + >>> print("Hello world!") + ``` + ```` + + ```rst + .. code-block:: pycon + >>> print("Hello world!") + ``` + + ````python + def add_one(n: int) -> int: + """ + Examples + -------- + ```pycon + >>> add_one(1) == 2 + ``` + """ + return n + 1 + ```` + +## blackdoc + +[`blackdoc`](https://blackdoc.readthedocs.io/en/stable) is primarily used to apply +_Black_ formatting to doctests in Python files. It will not format any file contents +that are otherwise covered by _Black_. + +`blackdoc` supports the following: + +- Doctests in Python files. + + ```python + def add_one(n: int) -> int: + """ + Examples + -------- + >>> add_one(1) == 2 + """ + return n + 1 + ``` + +- Python code blocks in Markdown or reStructuredText files. In these cases, normal + _Black_ formatting is applied, i.e., doctests inside Python code blocks will not be + formatted. + + ````md + ```python + print("Hello world!") + ``` + ```` + + ```rst + .. code-block:: python + print("Hello world!") + ``` diff --git a/docs/integrations/editors.md b/docs/integrations/editors.md new file mode 100644 index 0000000..aca0fa7 --- /dev/null +++ b/docs/integrations/editors.md @@ -0,0 +1,493 @@ +# Editor integration + +## Emacs + +Options include the following: + +- [emacs-python-black](https://github.com/wbolster/emacs-python-black) +- [Blacken](https://github.com/pythonic-emacs/blacken) +- [Elpy](https://elpy.readthedocs.io/en/stable/). + +## PyCharm/IntelliJ IDEA + +There are several different ways you can use _Black_ from PyCharm: + +1. Using the built-in _Black_ integration (PyCharm 2023.2 and later). This option is the + simplest to set up. +1. As local server using the BlackConnect plugin. This option formats the fastest. It + spins up {doc}`Black's HTTP server `, to + avoid the startup cost on subsequent formats. +1. As external tool. +1. As file watcher. + +### Built-in _Black_ integration + +1. Install `black`. + + ```console + $ pip install black + ``` + +1. Go to `Preferences or Settings -> Tools -> Black` and configure _Black_ to your + liking. + +### As local server + +1. Install _Black_ with the `d` extra. + + ```console + $ pip install 'black[d]' + ``` + +1. Install + [BlackConnect IntelliJ IDEs plugin](https://plugins.jetbrains.com/plugin/14321-blackconnect). + +1. Open plugin configuration in PyCharm/IntelliJ IDEA + + On macOS: + + `PyCharm -> Preferences -> Tools -> BlackConnect` + + On Windows / Linux / BSD: + + `File -> Settings -> Tools -> BlackConnect` + +1. In `Local Instance (shared between projects)` section: + 1. Check `Start local blackd instance when plugin loads`. + 1. Press the `Detect` button near `Path` input. The plugin should detect the `blackd` + executable. + +1. In `Trigger Settings` section check `Trigger on code reformat` to enable code + reformatting with _Black_. + +1. Format the currently opened file by selecting `Code -> Reformat Code` or using a + shortcut. + +1. Optionally, to run _Black_ on every file save: + - In `Trigger Settings` section of plugin configuration check + `Trigger when saving changed files`. + +### As external tool + +1. Install `black`. + + ```console + $ pip install black + ``` + +1. Locate your `black` installation folder. + + On macOS / Linux / BSD: + + ```console + $ which black + /usr/local/bin/black # possible location + ``` + + On Windows: + + ```console + $ where black + C:\Program Files\Python313\Scripts\black.exe # possible location + ``` + + Note that if you are using a virtual environment detected by PyCharm, this is an + unneeded step. In this case the path to `black` is `$PyInterpreterDirectory$/black`. + +1. Open External tools in PyCharm/IntelliJ IDEA + + On macOS: + + `PyCharm -> Preferences -> Tools -> External Tools` + + On Windows / Linux / BSD: + + `File -> Settings -> Tools -> External Tools` + +1. Click the + icon to add a new external tool with the following values: + - Name: Black + - Description: Black is the uncompromising Python code formatter. + - Program: \ + - Arguments: `"$FilePath$"` + +1. Format the currently opened file by selecting `Tools -> External Tools -> black`. + - Alternatively, you can set a keyboard shortcut by navigating to + `Preferences or Settings -> Keymap -> External Tools -> External Tools - Black`. + +### As file watcher + +1. Install `black`. + + ```console + $ pip install black + ``` + +1. Locate your `black` installation folder. + + On macOS / Linux / BSD: + + ```console + $ which black + /usr/local/bin/black # possible location + ``` + + On Windows: + + ```console + $ where black + C:\Program Files\Python313\Scripts\black.exe # possible location + ``` + + Note that if you are using a virtual environment detected by PyCharm, this is an + unneeded step. In this case the path to `black` is `$PyInterpreterDirectory$/black`. + +1. Make sure you have the + [File Watchers](https://plugins.jetbrains.com/plugin/7177-file-watchers) plugin + installed. +1. Go to `Preferences or Settings -> Tools -> File Watchers` and click `+` to add a new + watcher: + - Name: Black + - File type: Python + - Scope: Project Files + - Program: \ + - Arguments: `$FilePath$` + - Output paths to refresh: `$FilePath$` + - Working directory: `$ProjectFileDir$` + +- In Advanced Options + - Uncheck "Auto-save edited files to trigger the watcher" + - Uncheck "Trigger the watcher on external changes" + +## Wing IDE + +Wing IDE supports `black` via **Preference Settings** for system wide settings and +**Project Properties** for per-project or workspace specific settings, as explained in +the Wing documentation on +[Auto-Reformatting](https://wingware.com/doc/edit/auto-reformatting). The detailed +procedure is: + +### Prerequisites + +- Wing IDE version 8.0+ + +- Install `black`. + + ```console + $ pip install black + ``` + +- Make sure it runs from the command line, e.g. + + ```console + $ black --help + ``` + +### Preference Settings + +If you want Wing IDE to always reformat with `black` for every project, follow these +steps: + +1. In menubar navigate to `Edit -> Preferences -> Editor -> Reformatting`. + +1. Set **Auto-Reformat** from `disable` (default) to `Line after edit` or + `Whole files before save`. + +1. Set **Reformatter** from `PEP8` (default) to `Black`. + +### Project Properties + +If you want to just reformat for a specific project and not intervene with Wing IDE +global setting, follow these steps: + +1. In menubar navigate to `Project -> Project Properties -> Options`. + +1. Set **Auto-Reformat** from `Use Preferences setting` (default) to `Line after edit` + or `Whole files before save`. + +1. Set **Reformatter** from `Use Preferences setting` (default) to `Black`. + +## Vim + +### Official plugin + +Commands and shortcuts: + +- `:Black` to format the entire file (ranges not supported); + - you can optionally pass `target_version=` with the same values as in the + command line. +- `:BlackUpgrade` to upgrade _Black_ inside the virtualenv; +- `:BlackVersion` to get the current version of _Black_ in use. + +Configuration: + +- `g:black_fast` (defaults to `0`) +- `g:black_linelength` (defaults to `88`) +- `g:black_skip_string_normalization` (defaults to `0`) +- `g:black_skip_magic_trailing_comma` (defaults to `0`) +- `g:black_virtualenv` (defaults to `~/.vim/black` or `~/.local/share/nvim/black`) +- `g:black_use_virtualenv` (defaults to `1`) +- `g:black_target_version` (defaults to `""`) +- `g:black_quiet` (defaults to `0`) +- `g:black_preview` (defaults to `0`) + +#### Installation + +This plugin **requires Vim 7.0+ built with Python 3.10+ support**. It needs Python 3.10 +to be able to run _Black_ inside the Vim process which is much faster than calling an +external command. + +##### `vim-plug` + +To install with [vim-plug](https://junegunn.github.io/vim-plug/): + +_Black_'s `stable` branch tracks official version updates, and can be used to simply +follow the most recent stable version. + +```vim +Plug 'psf/black', { 'branch': 'stable' } +``` + +Another option which is a bit more explicit and offers more control is to use +`vim-plug`'s `tag` option with a shell wildcard. This will resolve to the latest tag +which matches the given pattern. + +The following matches all stable versions (see the +[Release Process](../contributing/release_process.md) section for documentation of +version scheme used by Black): + +```vim +Plug 'psf/black', { 'tag': '*.*.*' } +``` + +and the following demonstrates pinning to a specific year's stable style (2026 in this +case): + +```vim +Plug 'psf/black', { 'tag': '26.*.*' } +``` + +##### Vundle + +or with [Vundle](https://github.com/VundleVim/Vundle.vim): + +```vim +Plugin 'psf/black' +``` + +and execute the following in a terminal: + +```console +$ cd ~/.vim/bundle/black +$ git checkout origin/stable -b stable +``` + +##### Arch Linux + +On Arch Linux, the plugin is shipped with the +[`python-black`](https://archlinux.org/packages/extra/any/python-black/) package, so you +can start using it in Vim after install with no additional setup. + +##### Vim 8 Native Plugin Management + +or you can copy the plugin files from +[plugin/black.vim](https://github.com/psf/black/blob/stable/plugin/black.vim) and +[autoload/black.vim](https://github.com/psf/black/blob/stable/autoload/black.vim). + +```sh +mkdir -p ~/.vim/pack/python/start/black/plugin +mkdir -p ~/.vim/pack/python/start/black/autoload +curl https://raw.githubusercontent.com/psf/black/stable/plugin/black.vim -o ~/.vim/pack/python/start/black/plugin/black.vim +curl https://raw.githubusercontent.com/psf/black/stable/autoload/black.vim -o ~/.vim/pack/python/start/black/autoload/black.vim +``` + +Let me know if this requires any changes to work with Vim 8's builtin `packadd`, or +Pathogen, and so on. + +#### Usage + +On first run, the plugin creates its own virtualenv using the right Python version and +automatically installs _Black_. You can upgrade it later by calling `:BlackUpgrade` and +restarting Vim. + +If you need to do anything special to make your virtualenv work and install _Black_ (for +example you want to run a version from main), create a virtualenv manually and point +`g:black_virtualenv` to it. The plugin will use it. + +If you would prefer to use the system installation of _Black_ rather than a virtualenv, +then add this to your vimrc: + +```vim +let g:black_use_virtualenv = 0 +``` + +Note that the `:BlackUpgrade` command is only usable and useful with a virtualenv, so +when the virtualenv is not in use, `:BlackUpgrade` is disabled. If you need to upgrade +the system installation of _Black_, then use your system package manager or pip-- +whatever tool you used to install _Black_ originally. + +To run _Black_ on save, add the following lines to `.vimrc` or `init.vim`: + +```vim +augroup black_on_save + autocmd! + autocmd BufWritePre *.py Black +augroup end +``` + +To run _Black_ on a key press (e.g. F9 below), add this: + +```vim +nnoremap :Black +``` + +### With ALE + +1. Install [`ale`](https://github.com/dense-analysis/ale) + +1. Install `black` + +1. Add this to your vimrc: + + ```vim + let g:ale_fixers = {} + let g:ale_fixers.python = ['black'] + ``` + +## Neovim + +### Via conform.nvim + +[conform.nvim](https://github.com/stevearc/conform.nvim) is a lightweight formatter +plugin for Neovim. It supports _Black_ out of the box as long as `black` is available in +your `PATH`. + +1. Install `black` (e.g. `pip install black` or `pipx install black`) + +1. Install `conform.nvim` using your plugin manager and add the following to your Neovim + configuration: + + ```lua + require("conform").setup({ + formatters_by_ft = { + python = { "black" }, + }, + }) + ``` + +1. To format on save, add: + + ```lua + require("conform").setup({ + formatters_by_ft = { + python = { "black" }, + }, + format_on_save = { + timeout_ms = 500, + lsp_format = "fallback", + }, + }) + ``` + +### With ALE + +[ALE](https://github.com/dense-analysis/ale) supports both Vim and Neovim. See the +[Vim section](#with-ale) above for setup instructions — the same configuration works for +Neovim. + +### Simple command + +You can invoke _Black_ on the current file directly from Neovim without any plugins: + +```vim +:!black % +``` + +To create a convenient `:Black` command, add this to your `init.lua`: + +```lua +vim.api.nvim_create_user_command( + "Black", + function() + vim.cmd("!black " .. vim.fn.expand("%")) + end, + { nargs = 0 } +) +``` + +## Gedit + +gedit is the default text editor of the GNOME, Unix like Operating Systems. Open gedit +as + +```console +$ gedit +``` + +1. `Go to edit > preferences > plugins` +1. Search for `external tools` and activate it. +1. In `Tools menu -> Manage external tools` +1. Add a new tool using `+` button. +1. Copy the below content to the code window. + +```sh +#!/bin/bash +Name=$GEDIT_CURRENT_DOCUMENT_NAME +black $Name +``` + +- Set a keyboard shortcut if you like, Ex. `ctrl-B` +- Save: `Nothing` +- Input: `Nothing` +- Output: `Display in bottom pane` if you like. +- Change the name of the tool if you like. + +Use your keyboard shortcut or `Tools -> External Tools` to use your new tool. When you +close and reopen your File, _Black_ will be done with its job. + +## Visual Studio Code + +- Use the + [Python extension](https://marketplace.visualstudio.com/items?itemName=ms-python.python) + ([instructions](https://code.visualstudio.com/docs/python/formatting)). + +- Alternatively the pre-release + [Black Formatter](https://marketplace.visualstudio.com/items?itemName=ms-python.black-formatter) + extension can be used which runs a [Language Server Protocol](https://langserver.org/) + server for Black. Formatting is much more responsive using this extension, **but the + minimum supported version of Black is 22.3.0**. + +## SublimeText + +Use [LSP](#python-lsp-server) with the +[python-lsp-black](https://github.com/python-lsp/python-lsp-black) plugin as documented +below. This is the recommended approach for all versions of Sublime Text. + +```{note} +The [sublack plugin](https://github.com/jgirardet/sublack) that was previously +recommended here is no longer maintained (the repository has been archived). +``` + +## Python LSP Server + +If your editor supports the [Language Server Protocol](https://langserver.org/) (Atom, +Sublime Text, Visual Studio Code and many more), you can use the +[Python LSP Server](https://github.com/python-lsp/python-lsp-server) with the +[python-lsp-black](https://github.com/python-lsp/python-lsp-black) plugin. + +## Gradle (the build tool) + +Use the [Spotless](https://plugins.gradle.org/plugin/com.diffplug.spotless) plugin. + +## Kakoune + +Add the following hook to your kakrc, then run _Black_ with `:format`. + +``` +hook global WinSetOption filetype=python %{ + set-option window formatcmd 'black -q -' +} +``` + +## Thonny + +Use [Thonny-black-formatter](https://github.com/ettore-galli/thonny-black-formatter). diff --git a/docs/integrations/github_actions.md b/docs/integrations/github_actions.md new file mode 100644 index 0000000..a0b0d68 --- /dev/null +++ b/docs/integrations/github_actions.md @@ -0,0 +1,110 @@ +# GitHub Actions integration + +You can use _Black_ within a GitHub Actions workflow without setting your own Python +environment. Great for enforcing that your code matches the _Black_ code style. + +## Compatibility + +This action is known to support all GitHub-hosted runner OSes. In addition, only +published versions of _Black_ are supported (i.e. whatever is available on PyPI). + +Finally, this action installs _Black_ with the `colorama` extra so the `--color` flag +should work fine. + +## Usage + +Create a file named `.github/workflows/black.yml` inside your repository with: + +```yaml +name: Lint + +on: [push, pull_request] + +jobs: + lint: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v6 + - uses: psf/black@stable +``` + +We recommend the use of the `@stable` tag, but per version tags also exist if you prefer +that. Note that the action's version you select is independent of the version of _Black_ +the action will use. + +### Versions + +The version of _Black_ the action will use can be configured via `version` or read from +the `pyproject.toml` file. The action defaults to the latest release available on PyPI. + +`version` can be any +[valid version specifier](https://packaging.python.org/en/latest/glossary/#term-Version-Specifier) +or just the version number if you want an exact version. + +If you want to match versions covered by Black's +[stability policy](labels/stability-policy), you can use the compatible release operator +(`~=`): + +```yaml +- uses: psf/black@stable + with: + options: "--check --verbose" + src: "./src" + version: "~= 26.0" +``` + +To read the version from the `pyproject.toml` file instead, set `use_pyproject` to +`true`. This will first look into the `tool.black.required-version` field, then the +`dependency-groups` table, then the `project.dependencies` array and finally the +`project.optional-dependencies` table. Note that this requires Python >= 3.11, so using +the setup-python action may be required, for example: + +**Security note:** `use_pyproject` only accepts standard version specifiers for `black` +(for example `==`, `~=`, `>=` and ranges like `>=25,<26`). Direct references such as +`black @ https://...` are not supported. If your workflow runs on untrusted pull +requests (for example from forks), prefer setting `with.version` explicitly. + +```yaml +- uses: actions/setup-python@v6 + with: + python-version: "3.13" +- uses: psf/black@stable + with: + options: "--check --verbose" + src: "./src" + use_pyproject: true +``` + +Only versions available from PyPI are supported, so no commit SHAs or branch names. + +### Jupyter Notebooks + +If you want to include Jupyter Notebooks, it can be enabled by setting `jupyter` to +`true` (default is `false`): + +```yaml +- uses: psf/black@stable + with: + jupyter: true +``` + +See the [Jupyter Notebooks guide](../guides/using_black_with_jupyter_notebooks.md) for +more details. + +### CLI Options + +You can also configure the arguments passed to _Black_ via `options` (defaults to +`'--check --diff'`) and `src` (default is `'.'`). Please note that the +[`--check` flag](labels/exit-code) is required so that the workflow fails if _Black_ +finds files that need to be formatted. + +Here's an example configuration: + +```yaml +- uses: psf/black@stable + with: + options: "--check --verbose" + src: "./src" + jupyter: true + version: "21.5b1" +``` diff --git a/docs/integrations/index.md b/docs/integrations/index.md new file mode 100644 index 0000000..9a6222b --- /dev/null +++ b/docs/integrations/index.md @@ -0,0 +1,33 @@ +# Integrations + +```{toctree} +--- +hidden: +--- + +editors +github_actions +source_version_control +doctest_formatting +``` + +_Black_ can be integrated into many environments, providing a better and smoother +experience. Documentation for integrating _Black_ with a tool can be found for the +following areas: + +- {doc}`Editor / IDE <./editors>` +- {doc}`GitHub Actions <./github_actions>` +- {doc}`Source version control <./source_version_control>` +- {doc}`Doctest formatting <./doctest_formatting>` + +Editors and tools not listed will require external contributions. + +Patches welcome! ✨ 🍰 ✨ + +Any tool can pipe code through _Black_ using its stdio mode (just +[use `-` as the file name](https://www.tldp.org/LDP/abs/html/special-chars.html#DASHREF2)). +The formatted code will be returned on stdout (unless `--check` was passed). _Black_ +will still emit messages on stderr but that shouldn't affect your use case. + +This can be used for example with PyCharm's or IntelliJ's +[File Watchers](https://www.jetbrains.com/help/pycharm/file-watchers.html). diff --git a/docs/integrations/source_version_control.md b/docs/integrations/source_version_control.md new file mode 100644 index 0000000..2d17847 --- /dev/null +++ b/docs/integrations/source_version_control.md @@ -0,0 +1,102 @@ +# Version control integration + +Use [pre-commit](https://pre-commit.com/). Once you +[have it installed](https://pre-commit.com/#install), add this to the +`.pre-commit-config.yaml` in your repository: + +```yaml +repos: + # Using this mirror lets us use mypyc-compiled black, which is about 2x faster + - repo: https://github.com/psf/black-pre-commit-mirror + rev: 26.5.1 + hooks: + - id: black + # It is recommended to specify the latest version of Python + # supported by your project here, or alternatively use + # pre-commit's default_language_version, see + # https://pre-commit.com/#top_level-default_language_version + language_version: python3.11 +``` + +Feel free to switch out the `rev` value to a different version of Black. + +Note if you'd like to use a specific commit in `rev`, you'll need to swap the repo +specified from the mirror to https://github.com/psf/black. We discourage the use of +branches or other mutable refs since the hook [won't auto update as you may +expect][pre-commit-mutable-rev]. + +## Jupyter Notebooks + +There is an alternate hook `black-jupyter` that expands the targets of `black` to +include Jupyter Notebooks. To use this hook, simply replace the hook's `id: black` with +`id: black-jupyter` in the `.pre-commit-config.yaml`: + +```yaml +repos: + - repo: https://github.com/psf/black-pre-commit-mirror + rev: 26.5.1 + hooks: + - id: black-jupyter + language_version: python3.11 +``` + +```{note} +The `black-jupyter` hook became available in version 21.8b0. +``` + +See the [Jupyter Notebooks guide](../guides/using_black_with_jupyter_notebooks.md) for +more details. + +## Excluding files with pre-commit + +When using pre-commit, there's an important distinction in how file exclusions work. +Pre-commit passes files directly to Black via the command line, rather than letting +Black discover files recursively. This means Black's `--exclude` option won't work as +expected because it only applies to files discovered during recursive directory +traversal. + +To exclude files when using pre-commit, you have two options: + +### Option 1: Use pre-commit's exclude (Recommended) + +Configure exclusions directly in `.pre-commit-config.yaml`: + +```yaml +repos: + - repo: https://github.com/psf/black-pre-commit-mirror + rev: 26.5.1 + hooks: + - id: black + exclude: ^migrations/|^generated/ +``` + +This is the recommended approach because pre-commit filters files before passing them to +Black, avoiding unnecessary processing. + +### Option 2: Use Black's force-exclude in pyproject.toml + +Black's `force-exclude` configuration option excludes files even when they are passed +explicitly as command-line arguments (which is how pre-commit invokes Black). Simply add +the pattern to your `pyproject.toml`: + +```toml +[tool.black] +force-exclude = ''' +( + ^migrations/ + | ^generated/ +) +''' +``` + +Black automatically reads this configuration—no additional CLI arguments are needed in +your `.pre-commit-config.yaml`. + +```{note} +The `force-exclude` option was added in version 20.8b0 specifically to support +workflows where files are passed directly via CLI, such as pre-commit hooks and +editor plugins. +``` + +[pre-commit-mutable-rev]: + https://pre-commit.com/#using-the-latest-version-for-a-repository diff --git a/docs/license.md b/docs/license.md new file mode 100644 index 0000000..132c95b --- /dev/null +++ b/docs/license.md @@ -0,0 +1,9 @@ +--- +orphan: true +--- + +# License + +```{include} ../LICENSE + +``` diff --git a/docs/make.bat b/docs/make.bat new file mode 100644 index 0000000..79372c6 --- /dev/null +++ b/docs/make.bat @@ -0,0 +1,36 @@ +@ECHO OFF + +pushd %~dp0 + +REM Command file for Sphinx documentation + +if "%SPHINXBUILD%" == "" ( + set SPHINXBUILD=sphinx-build +) +set SOURCEDIR=. +set BUILDDIR=_build +set SPHINXPROJ=black + +if "%1" == "" goto help + +%SPHINXBUILD% >NUL 2>NUL +if errorlevel 9009 ( + echo. + echo.The 'sphinx-build' command was not found. Make sure you have Sphinx + echo.installed, then set the SPHINXBUILD environment variable to point + echo.to the full path of the 'sphinx-build' executable. Alternatively you + echo.may add the Sphinx directory to PATH. + echo. + echo.If you don't have Sphinx installed, grab it from + echo.http://sphinx-doc.org/ + exit /b 1 +) + +%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% +goto end + +:help +%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% + +:end +popd diff --git a/docs/the_black_code_style/current_style.md b/docs/the_black_code_style/current_style.md new file mode 100644 index 0000000..09e5b13 --- /dev/null +++ b/docs/the_black_code_style/current_style.md @@ -0,0 +1,505 @@ +# The _Black_ code style + +## Code style + +_Black_ aims for consistency, generality, readability and reducing git diffs. Similar +language constructs are formatted with similar rules. Style configuration options are +deliberately limited and rarely added. Previous formatting is taken into account as +little as possible, with rare exceptions like the magic trailing comma. The coding style +used by _Black_ follows PEP 8 in spirit and enforces a consistent subset of its +formatting recommendations. It does not implement every style rule covered by PEP 8. + +This document describes the current formatting style. If you're interested in trying out +where the style is heading, see [future style](./future_style.md) and try running +`black --preview`. + +### How _Black_ wraps lines + +_Black_ ignores previous formatting and applies uniform horizontal and vertical +whitespace to your code. The rules for horizontal whitespace can be summarized as: do +whatever makes `pycodestyle` happy. + +As for vertical whitespace, _Black_ tries to render one full expression or simple +statement per line. If this fits the allotted line length, great. + +```python +# in: + +j = [1, + 2, + 3 +] + +# out: + +j = [1, 2, 3] +``` + +If not, _Black_ will look at the contents of the first outer matching brackets and put +that in a separate indented line. + +```python +# in: + +ImportantClass.important_method(exc, limit, lookup_lines, capture_locals, extra_argument) + +# out: + +ImportantClass.important_method( + exc, limit, lookup_lines, capture_locals, extra_argument +) +``` + +If that still doesn't fit the bill, it will decompose the internal expression further +using the same rule, indenting matching brackets every time. If the contents of the +matching brackets pair are comma-separated (like an argument list, or a dict literal, +and so on) then _Black_ will first try to keep them on the same line with the matching +brackets. If that doesn't work, it will put all of them in separate lines. + +```python +# in: + +def very_important_function(template: str, *variables, file: os.PathLike, engine: str, header: bool = True, debug: bool = False): + """Applies `variables` to the `template` and writes to `file`.""" + with open(file, 'w') as f: + ... + +# out: + +def very_important_function( + template: str, + *variables, + file: os.PathLike, + engine: str, + header: bool = True, + debug: bool = False, +): + """Applies `variables` to the `template` and writes to `file`.""" + with open(file, "w") as f: + ... +``` + +If a data structure literal (tuple, list, set, dict) or a line of "from" imports cannot +fit in the allotted length, it's always split into one element per line. This minimizes +diffs as well as enables readers of code to find which commit introduced a particular +entry. This also makes _Black_ compatible with +[isort](../guides/using_black_with_other_tools.md#isort) with the ready-made `black` +profile or manual configuration. + +You might have noticed that closing brackets are always dedented and that a trailing +comma is always added. Such formatting produces smaller diffs; when you add or remove an +element, it's always just one line. Also, having the closing bracket dedented provides a +clear delimiter between two distinct sections of the code that otherwise share the same +indentation level (like the arguments list and the docstring in the example above). + +(labels/why-no-backslashes)= + +_Black_ prefers parentheses over backslashes, and will remove backslashes if found. + +```python +# in: + +if some_short_rule1 \ + and some_short_rule2: + ... + +# out: + +if some_short_rule1 and some_short_rule2: + ... + + +# in: + +if some_long_rule1 \ + and some_long_rule2: + ... + +# out: + +if ( + some_long_rule1 + and some_long_rule2 +): + ... + +``` + +Backslashes and multiline strings are one of the two places in the Python grammar that +break significant indentation. You never need backslashes, they are used to force the +grammar to accept breaks that would otherwise be parse errors. That makes them confusing +to look at and brittle to modify. This is why _Black_ always gets rid of them. + +If you're reaching for backslashes, that's a clear signal that you can do better if you +slightly refactor your code. I hope some of the examples above show you that there are +many ways in which you can do it. + +(labels/line-length)= + +### Line length + +You probably noticed the peculiar default line length. _Black_ defaults to 88 characters +per line, which happens to be 10% over 80. This number was found to produce +significantly shorter files than sticking with 80 (the most popular), or even 79 (used +by the standard library). In general, +[90-ish seems like the wise choice](https://youtu.be/wf-BqAjZb8M?t=260). + +If you're paid by the lines of code you write, you can pass `--line-length` with a lower +number. _Black_ will try to respect that. However, sometimes it won't be able to without +breaking other rules. In those rare cases, auto-formatted code will exceed your allotted +limit. + +You can also increase it, but remember that people with sight disabilities find it +harder to work with line lengths exceeding 100 characters. It also adversely affects +side-by-side diff review on typical screen resolutions. Long lines also make it harder +to present code neatly in documentation or talk slides. + +#### Flake8 and other linters + +See [Using _Black_ with other tools](../guides/using_black_with_other_tools.md) about +linter compatibility. + +### Empty lines + +_Black_ avoids spurious vertical whitespace. This is in the spirit of PEP 8 which says +that in-function vertical whitespace should only be used sparingly. + +_Black_ will allow single empty lines inside functions, and single and double empty +lines on module level left by the original editors, except when they're within +parenthesized expressions. Since such expressions are always reformatted to fit minimal +space, this whitespace is lost. + +```python +# in: + +def function( + some_argument: int, + + other_argument: int = 5, +) -> EmptyLineInParenWillBeDeleted: + + + + print("One empty line above me will be kept!") + +def this_is_okay_too(): + print("No empty line here") +# out: + +def function( + some_argument: int, + other_argument: int = 5, +) -> EmptyLineInParenWillBeDeleted: + + print("One empty line above me will be kept!") + + +def this_is_okay_too(): + print("No empty line here") +``` + +It will also insert proper spacing before and after function definitions. It's one line +before and after inner functions and two lines before and after module-level functions +and classes. _Black_ will not put empty lines between function/class definitions and +standalone comments that immediately precede the given function/class. + +_Black_ will enforce single empty lines between a class-level docstring and the first +following field or method. This conforms to +[PEP 257](https://peps.python.org/pep-0257/#multi-line-docstrings). + +_Black_ won't insert empty lines after function docstrings unless that empty line is +required due to an inner function starting immediately after. + +### Comments + +_Black_ does not format comment contents, but it enforces two spaces between code and a +comment on the same line, and a space before the comment text begins. Some types of +comments that require specific spacing rules are respected: shebangs (`#! comment`), doc +comments (`#: comment`), section comments with long runs of hashes, and Spyder cells. +Non-breaking spaces after hashes are also preserved. Comments may sometimes be moved +because of formatting changes, which can break tools that assign special meaning to +them. See [AST before and after formatting](#ast-before-and-after-formatting) for more +discussion. + +### Trailing commas + +_Black_ will add trailing commas to expressions that are split by comma where each +element is on its own line. This includes function signatures. + +One exception to adding trailing commas is function signatures containing `*`, `*args`, +or `**kwargs`. In this case a trailing comma is only safe to use on Python 3.6. _Black_ +will detect if your file is already 3.6+ only and use trailing commas in this situation. +If you wonder how it knows, it looks for f-strings and existing use of trailing commas +in function signatures that have stars in them. In other words, if you'd like a trailing +comma in this situation and _Black_ didn't recognize it was safe to do so, put it there +manually and _Black_ will keep it. + +A pre-existing trailing comma informs _Black_ to always explode contents of the current +bracket pair into one item per line. Read more about this in the +[Pragmatism](#pragmatism) section below. + +(labels/strings)= + +### Strings + +_Black_ prefers double quotes (`"` and `"""`) over single quotes (`'` and `'''`). It +will replace the latter with the former as long as it does not result in more backslash +escapes than before. + +_Black_ also standardizes string prefixes. Prefix characters are made lowercase with the +exception of [capital "R" prefixes](#rstrings-and-rstrings), unicode literal markers +(`u`) are removed because they are meaningless in Python 3, and in the case of multiple +characters "r" is put first as in spoken language: "raw f-string". + +Another area where Python allows multiple ways to format a string is escape sequences. +For example, `"\uabcd"` and `"\uABCD"` evaluate to the same string. _Black_ normalizes +such escape sequences to lowercase, but uses uppercase for `\N` named character escapes, +such as `"\N{MEETEI MAYEK LETTER HUK}"`. + +The main reason to standardize on a single form of quotes is aesthetics. Having one kind +of quotes everywhere reduces reader distraction. It will also enable a future version of +_Black_ to merge consecutive string literals that ended up on the same line (see +[#26](https://github.com/psf/black/issues/26) for details). + +Why settle on double quotes? They anticipate apostrophes in English text. They match the +docstring standard described in +[PEP 257](https://peps.python.org/pep-0257/#what-is-a-docstring). An empty string in +double quotes (`""`) is impossible to confuse with a one double-quote regardless of +fonts and syntax highlighting used. On top of this, double quotes for strings are +consistent with C which Python interacts a lot with. + +On certain keyboard layouts like US English, typing single quotes is a bit easier than +double quotes. The latter requires use of the Shift key. My recommendation here is to +keep using whatever is faster to type and let _Black_ handle the transformation. + +If you are adopting _Black_ in a large project with pre-existing string conventions +(like the popular +["single quotes for data, double quotes for human-readable strings"](https://stackoverflow.com/a/56190)), +you can pass `--skip-string-normalization` on the command line. This is meant as an +adoption helper, avoid using this for new projects. + +_Black_ also processes docstrings. Firstly the indentation of docstrings is corrected +for both quotations and the text within, although relative indentation in the text is +preserved. Superfluous trailing whitespace on each line and unnecessary new lines at the +end of the docstring are removed. All leading tabs are converted to spaces, but tabs +inside text are preserved. Whitespace leading and trailing one-line docstrings is +removed. + +### Numeric literals + +_Black_ standardizes most numeric literals to use lowercase letters for the syntactic +parts and uppercase letters for the digits themselves: `0xAB` instead of `0XAB` and +`1e10` instead of `1E10`. + +### Line breaks & binary operators + +_Black_ will break a line before a binary operator when splitting a block of code over +multiple lines. This is so that _Black_ is compliant with the recent changes in the +[PEP 8](https://peps.python.org/pep-0008/#should-a-line-break-before-or-after-a-binary-operator) +style guide, which emphasizes that this approach improves readability. + +Almost all operators will be surrounded by single spaces, the only exceptions are unary +operators (`+`, `-`, and `~`), and power operators when both operands are simple. For +powers, an operand is considered simple if it's only a NAME, numeric CONSTANT, or +attribute access (chained attribute access is allowed), with or without a preceding +unary operator. + +```python +# For example, these won't be surrounded by whitespace +a = x**y +b = config.base**5.2 +c = config.base**runtime.config.exponent +d = 2**5 +e = 2**~5 + +# ... but these will be surrounded by whitespace +f = 2 ** get_exponent() +g = get_x() ** get_y() +h = config['base'] ** 2 +``` + +### Slices + +PEP 8 +[recommends](https://peps.python.org/pep-0008/#whitespace-in-expressions-and-statements) +to treat `:` in slices as a binary operator with the lowest priority, and to leave an +equal amount of space on either side, except if a parameter is omitted (e.g. +`ham[1 + 1 :]`). It recommends no spaces around `:` operators for "simple expressions" +(`ham[lower:upper]`), and extra space for "complex expressions" +(`ham[lower : upper + offset]`). _Black_ treats anything more than variable names as +"complex" (`ham[lower : upper + 1]`). It also states that for extended slices, both `:` +operators have to have the same amount of spacing, except if a parameter is omitted +(`ham[1 + 1 ::]`). _Black_ enforces these rules consistently. + +This behaviour may raise `E203 whitespace before ':'` warnings in style guide +enforcement tools like Flake8. Since `E203` is not PEP 8 compliant, you should tell +Flake8 to ignore these warnings. + +### Parentheses + +Some parentheses are optional in the Python grammar. Any expression can be wrapped in a +pair of parentheses to form an atom. There are a few interesting cases: + +- `if (...):` +- `while (...):` +- `for (...) in (...):` +- `assert (...), (...)` +- `from X import (...)` +- assignments like: + - `target = (...)` + - `target: type = (...)` + - `some, *un, packing = (...)` + - `augmented += (...)` + +In those cases, parentheses are removed when the entire statement fits in one line, or +if the inner expression doesn't have any delimiters to further split on. If there is +only a single delimiter and the expression starts or ends with a bracket, the +parentheses can also be successfully omitted since the existing bracket pair will +organize the expression neatly anyway. Otherwise, the parentheses are added. + +Please note that _Black_ does not add or remove any additional nested parentheses that +you might want to have for clarity or further code organization. For example those +parentheses are not going to be removed: + +```python +return not (this or that) +decision = (maybe.this() and values > 0) or (maybe.that() and values < 0) +``` + +### Call chains + +Some popular APIs, like ORMs, use call chaining. This API style is known as a +[fluent interface](https://en.wikipedia.org/wiki/Fluent_interface). _Black_ formats +those by treating dots that follow a call or an indexing operation like a very low +priority delimiter. It's easier to show the behavior than to explain it. Look at the +example: + +```python +def example(session): + result = ( + session.query(models.Customer.id) + .filter( + models.Customer.account_id == account_id, + models.Customer.email == email_address, + ) + .order_by(models.Customer.id.asc()) + .all() + ) +``` + +### Typing stub files + +PEP 484 describes the syntax for type hints in Python. One of the use cases for typing +is providing type annotations for modules which cannot contain them directly (they might +be written in C, or they might be third-party, or their implementation may be overly +dynamic, and so on). + +To solve this, +[stub files with the `.pyi` file extension](https://peps.python.org/pep-0484/#stub-files) +can be used to describe typing information for an external module. Those stub files omit +the implementation of classes and functions they describe, instead they only contain the +structure of the file (listing globals, functions, and classes with their members). The +recommended code style for those files is more terse than PEP 8: + +- prefer `...` on the same line as the class/function signature; +- avoid vertical whitespace between consecutive module-level functions, names, or + methods and fields within a single class; +- use a single blank line between top-level class definitions, or none if the classes + are very small. + +_Black_ enforces the above rules. There are additional guidelines for formatting `.pyi` +file that are not enforced yet but might be in a future version of the formatter: + +- prefer `...` over `pass`; +- avoid using string literals in type annotations, stub files support forward references + natively (like Python 3.7 code with `from __future__ import annotations`); +- use variable annotations instead of type comments, even for stubs that target older + versions of Python. + +### Line endings + +_Black_ will normalize line endings (`\n` or `\r\n`) based on the first line ending of +the file. + +### Form feed characters + +_Black_ will retain form feed characters on otherwise empty lines at the module level. +Only one form feed is retained for a group of consecutive empty lines. Where there are +two empty lines in a row, the form feed is placed on the second line. + +## Pragmatism + +Early versions of _Black_ used to be absolutist in some respects. They took after its +initial author. This was fine at the time as it made the implementation simpler and +there were not many users anyway. Not many edge cases were reported. As a mature tool, +_Black_ does make some exceptions to rules it otherwise holds. This section documents +what those exceptions are and why this is the case. + +(labels/magic-trailing-comma)= + +### The magic trailing comma + +_Black_ in general does not take existing formatting into account. + +However, there are cases where you put a short collection or function call in your code +but you anticipate it will grow in the future. + +For example: + +```python +TRANSLATIONS = { + "en_us": "English (US)", + "pl_pl": "polski", +} +``` + +Early versions of _Black_ used to ruthlessly collapse those into one line (it fits!). +Now, you can communicate that you don't want that by putting a trailing comma in the +collection yourself. When you do, _Black_ will know to always explode your collection +into one item per line. + +How do you make it stop? Just delete that trailing comma and _Black_ will collapse your +collection into one line if it fits. + +If you must, you can recover the behaviour of early versions of _Black_ with the option +`--skip-magic-trailing-comma` / `-C`. + +### r"strings" and R"strings" + +_Black_ normalizes string quotes as well as string prefixes, making them lowercase. One +exception to this rule is r-strings. It turns out that the very popular +[MagicPython](https://github.com/MagicStack/MagicPython/) syntax highlighter, used by +default by (among others) GitHub and Visual Studio Code, differentiates between +r-strings and R-strings. The former are syntax highlighted as regular expressions while +the latter are treated as true raw strings with no special semantics. + +(labels/ast-changes)= + +### AST before and after formatting + +When run with `--safe` (the default), _Black_ checks that the code before and after is +semantically equivalent. This check is done by comparing the AST of the source with the +AST of the target. There are three limited cases in which the AST does differ: + +1. _Black_ cleans up leading and trailing whitespace of docstrings, re-indenting them if + needed. It's been one of the most popular user-reported features for the formatter to + fix whitespace issues with docstrings. While the result is technically an AST + difference, due to the various possibilities of forming docstrings, all real-world + uses of docstrings that we're aware of sanitize indentation and leading/trailing + whitespace anyway. + +1. _Black_ manages optional parentheses for some statements. In the case of the `del` + statement, presence of wrapping parentheses or lack thereof changes the resulting AST + but is semantically equivalent in the interpreter. + +1. _Black_ might move comments around, which includes type comments. Those are part of + the AST as of Python 3.8. While the tool implements a number of special cases for + those comments, there is no guarantee they will remain where they were in the source. + Note that this doesn't change runtime behavior of the source code. + +To put things in perspective, the code equivalence check is a feature of _Black_ which +other formatters don't implement at all. It is of crucial importance to us to ensure +code behaves the way it did before it got reformatted. We treat this as a feature and +there are no plans to relax this in the future. The exceptions enumerated above stem +from either user feedback or implementation details of the tool. In each case we made +due diligence to ensure that the AST divergence is of no practical consequence. diff --git a/docs/the_black_code_style/future_style.md b/docs/the_black_code_style/future_style.md new file mode 100644 index 0000000..00cd4af --- /dev/null +++ b/docs/the_black_code_style/future_style.md @@ -0,0 +1,500 @@ +# The (future of the) Black code style + +## Preview style + +(labels/preview-style)= + +Experimental, potentially disruptive style changes are gathered under the `--preview` +CLI flag. At the end of each year, these changes may be adopted into the default style, +as described in [The Black Code Style](index.md). Because the functionality is +experimental, feedback and issue reports are highly encouraged! + +(labels/preview-features)= + +Currently, the following features are included in the preview style: + +- `wrap_comprehension_in`: Wrap the `in` clause of list and dictionary comprehensions + across lines if it would otherwise exceed the maximum line length. + ([see below](labels/wrap-comprehension-in)) +- `simplify_power_operator_hugging`: Use a simpler implementation of the power operator + "hugging" logic (removing whitespace around `**` in simple expressions), which applies + also in the rare case the exponentiation is split into separate lines. + ([see below](labels/simplify-power-operator)) +- `wrap_long_dict_values_in_parens`: Add parentheses around long values in dictionaries. + ([see below](labels/wrap-long-dict-values)) +- `fix_if_guard_explosion_in_case_statement`: fixed exploding of the if guard in case + patterns which have trailing commas in them, even if the guard expression fits in one + line +- `pyi_overload_group_blank_lines`: In `.pyi` stub files, improve heuristics around when + blank lines should appear before, after and within decorated function groups. + ([see below](labels/pyi-overload-group)) +- `pyi_blank_line_before_decorated_class`: In `.pyi` stub files, enforce a blank line + before a decorated class definition when it follows a function definition. + ([see below](labels/pyi-blank-line-before-decorated-class)) +- `fix_unnecessary_parens_in_indexed_assignment`: Remove unnecessary parentheses around + the right-hand side of indexed assignments (e.g. `x[key] = expr`) when the subscripted + target is too long to fit on one line and the expression fits on the tail line. + ([see below](labels/fix-unnecessary-parens-indexed-assignment)) +- `pyi_blank_line_after_function_docstring`: In `.pyi` stub files, enforce a blank line + after a function or method body that consists of a docstring. + ([see below](labels/pyi-blank-line-after-function-docstring)) +- `hug_comparator`: Don't break a comparator (`not in`, `==`, `is`, ...) away from its + left operand when the right operand is a bracketed expression that has to break + anyway; let the bracket explode instead. ([see below](labels/hug-comparator)) +- `parenthesize_tuple_in_yield`: Add parentheses around tuple expressions in `yield` + statements. + +(labels/wrap-comprehension-in)= + +### Wrapping long comprehension `in` clauses + +When a list or dictionary comprehension has a long `in` clause that would exceed the +maximum line length, Black will wrap it across multiple lines for better readability. +This helps keep comprehensions readable when the iterable expression is complex or +lengthy. + +For example: + +```python +# Before +result = [ + very_very_very_very_very_long_item + for very_very_very_very_very_long_item in some_very_very_very_very_very_very_long_function_name +] +``` + +will be formatted to: + +```python +# After +result = [ + very_very_very_very_very_long_item + for very_very_very_very_very_long_item in ( + some_very_very_very_very_very_very_long_function_name + ) +] +``` + +This also applies to dictionary comprehensions: + +```python +# Before +mapping = { + very_long_key: very_very_very_long_item + for very_long_key, very_very_very_long_item in very_very_very_very_long_function_name +} +``` + +will be formatted to: + +```python +# After +mapping = { + very_long_key: very_very_very_long_item + for very_long_key, very_very_very_long_item in ( + very_very_very_very_long_function_name + ) +} +``` + +(labels/simplify-power-operator)= + +### Simplified power operator whitespace handling + +Black's power operator "hugging" logic removes whitespace around `**` in simple +expressions (e.g., `x**2` instead of `x ** 2`). This feature uses a simpler, more +consistent implementation that also applies when exponentiation is split across lines. + +For example: + +```python +# Simple expressions - whitespace is removed +result = x**2 + y**3 +value = base**exponent +``` + +When the exponentiation is split across lines (rare), the simplified logic ensures +consistent formatting: + +```python +# Complex expression split across lines +result = ( + some_very_long_base_expression + **some_very_long_exponent_expression + **some_very_long_third_expression +) +``` + +This feature primarily improves the internal consistency of Black's formatting logic +rather than making dramatic visual changes to most code. + +(labels/wrap-long-dict-values)= + +### Improved parentheses management in dicts + +For dict literals with long values, they are now wrapped in parentheses. Unnecessary +parentheses are now removed. For example: + +```python +my_dict = { + "a key in my dict": a_very_long_variable + * and_a_very_long_function_call() + / 100000.0, + "another key": (short_value), +} +``` + +will be changed to: + +```python +my_dict = { + "a key in my dict": ( + a_very_long_variable * and_a_very_long_function_call() / 100000.0 + ), + "another key": short_value, +} +``` + +(labels/pyi-overload-group)= + +### Improved overload groups in stub files + +In `.pyi` stub files, Black now has improved heuristics regarding when blank lines +should appear before, after or within groups of decorated functions that share the same +name (such as `@overload` groups). Two rules are applied when a decorated function is +determined to be part of a series of >=2 decorated functions with the same name: + +1. **Before the decorated function**: a blank line is always inserted, unless the + preceding statement is a same-name decorated function (i.e. part of an `@overload` + group) or the function is the first statement in its block. +2. **After the decorated function**: a blank line is always inserted, unless the + following statement is a same-name decorated function. + +These rules apply regardless of what the adjacent statement is — whether it's another +function definition, a variable annotation, or any other statement. + +Previously, Black could insert unwanted blank lines _within_ an overload group when one +of the overloads had a docstring, and did not consistently enforce blank lines at the +boundaries of overload groups: + +```python +# Before + +@overload +def foo(x: int) -> int: + """Docs.""" + +@overload # unwanted blank line within group +def foo(x: str) -> str: ... +def bar(x): ... # no blank line after group +``` + +With this feature enabled, the group is kept together and clearly separated from +surrounding code: + +```python +# After (with --preview) + +@overload +def foo(x: int) -> int: + """Docs.""" +@overload +def foo(x: str) -> str: ... + +def bar(x): ... +``` + +(labels/pyi-blank-line-before-decorated-class)= + +### Blank line before decorated classes in stub files + +In `.pyi` stub files, Black already enforces blank lines around class definitions in +many situations. However, when a class has a decorator, Black previously failed to +enforce this, instead _removing_ the blank line between a function and the decorator: + +```diff + # Before + + def foo(): ... +- + @decorator + class Bar: ... + + def baz(): ... + @decorator + class Spam: ... +``` + +With this feature enabled, a blank line is enforced, consistent with how undecorated +classes are handled: + +```diff + # After (with --preview) + + def foo(): ... + + @decorator + class Bar: ... + + def baz(): ... ++ + @decorator + class Spam: ... +``` + +(labels/fix-unnecessary-parens-indexed-assignment)= + +### Unnecessary parentheses in indexed assignments + +When an assignment target ends with a subscript (e.g. `x[key] = expr`) and is too long +to fit on one line, Black has to split at the subscript's brackets. Previously it would +additionally wrap the right-hand side expression in parentheses, even when the +expression fits on the closing line. With this feature enabled, Black omits those +unnecessary parentheses. + +For example: + +```python +# Before +dictionary_of_arrays["long_key_name_for_the_example"][ + very_long_index_name, index_zero +] = (10 - 5) +``` + +will be formatted to: + +```python +# After (with --preview) +dictionary_of_arrays["long_key_name_for_the_example"][ + very_long_index_name, index_zero +] = 10 - 5 +``` + +Assignments whose target fits on one line are not affected: wrapping the right-hand side +in parentheses remains the preferred style there. + +(labels/pyi-blank-line-after-function-docstring)= + +### Blank line after function docstrings in stub files + +In `.pyi` stub files, functions and methods sometimes use a docstring as their whole +body. Black already separated these definitions from a following function definition, +but did not consistently do the same before a following comment, conditional block, +variable annotation, or other statement: + +```python +# Before + +class Example: + def method(self) -> None: + """Documentation.""" + # comment for the next member + attr: int +``` + +With this feature enabled, the docstring-only function body is consistently separated +from the next comment or statement: + +```python +# After (with --preview) + +class Example: + def method(self) -> None: + """Documentation.""" + + # comment for the next member + attr: int +``` + +Black still keeps same-name decorated functions, such as `@overload` groups and property +setters, together without inserting blank lines between them. + +(labels/hug-comparator)= + +### Keep comparators next to their left operand + +When a comparator (`not in`, `==`, `is`, ...) sits inside another bracketed construct +and its right operand is a bracketed expression that has to break (either via a magic +trailing comma or because the line is too long), Black used to split the line right +before the comparator. The left operand ended up alone on its own line, visually +disconnected from the operator and the operand that explains it: + +```python +# Before + +x = [ + t + for t in y + if t + not in { + LongNameOne, + LongNameTwo, + LongNameThree, + } +] +``` + +With this feature enabled, Black skips that comparator split and lets the right-hand +bracket explode instead, which it would have done anyway: + +```python +# After (with --preview) + +x = [ + t + for t in y + if t not in { + LongNameOne, + LongNameTwo, + LongNameThree, + } +] +``` + +The fix is not limited to comprehensions. The same shape appears inside `if`/`elif` +chains, `assert` statements, and parenthesized expressions, and gets the same treatment: + +```python +# Before + +if ( + is_scalar(value) + and self.dtype + in (np.dtype("float64"), np.dtype("float32"), np.dtype("object")) + and (limit is not None or inplace) +): + ... + +assert ( + bool + is _AnnotationExtractor(attr.fields(C).x.converter.__call__).get_return_type() +) +``` + +```python +# After (with --preview) + +if ( + is_scalar(value) + and self.dtype in ( + np.dtype("float64"), + np.dtype("float32"), + np.dtype("object"), + ) + and (limit is not None or inplace) +): + ... + +assert ( + bool is _AnnotationExtractor( + attr.fields(C).x.converter.__call__ + ).get_return_type() +) +``` + +## Unstable style + +(labels/unstable-style)= + +In the past, the preview style included some features with known bugs, so that we were +unable to move these features to the stable style. Therefore, such features are now +moved to the `--unstable` style. All features in the `--preview` style are expected to +make it to next year's stable style; features in the `--unstable` style will be +stabilized only if issues with them are fixed. If bugs are discovered in a `--preview` +feature, it is demoted to the `--unstable` style. To avoid thrash when a feature is +demoted from the `--preview` to the `--unstable` style, users can use the +`--enable-unstable-feature` flag to enable specific unstable features. + +(labels/unstable-features)= + +The unstable style additionally includes the following features: + +- `hug_parens_with_braces_and_square_brackets`: More compact formatting of nested + brackets. ([see below](labels/hug-parens)) +- `string_processing`: Split long string literals and related changes. + ([see below](labels/string-processing)) + +(labels/hug-parens)= + +### Improved multiline dictionary and list indentation for sole function parameter + +For better readability and less verticality, _Black_ now pairs parentheses ("(", ")") +with braces ("{", "}") and square brackets ("[", "]") on the same line. For example: + +```python +foo( + [ + 1, + 2, + 3, + ] +) + +nested_array = [ + [ + 1, + 2, + 3, + ] +] +``` + +will be changed to: + +```python +foo([ + 1, + 2, + 3, +]) + +nested_array = [[ + 1, + 2, + 3, +]] +``` + +This also applies to list and dictionary unpacking: + +```python +foo( + *[ + a_long_function_name(a_long_variable_name) + for a_long_variable_name in some_generator + ] +) +``` + +will become: + +```python +foo(*[ + a_long_function_name(a_long_variable_name) + for a_long_variable_name in some_generator +]) +``` + +You can use a magic trailing comma to avoid this compacting behavior; by default, +_Black_ will not reformat the following code: + +```python +foo( + [ + 1, + 2, + 3, + ], +) +``` + +(labels/string-processing)= + +### Improved string processing + +_Black_ will split long string literals and merge short ones. Parentheses are used where +appropriate. When split, parts of f-strings that don't need formatting are converted to +plain strings. f-strings will not be merged if they contain internal quotes and it would +change their quotation mark style. Line continuation backslashes are converted into +parenthesized strings. Unnecessary parentheses are stripped. The stability and status of +this feature is tracked in [this issue](https://github.com/psf/black/issues/2188). diff --git a/docs/the_black_code_style/index.md b/docs/the_black_code_style/index.md new file mode 100644 index 0000000..29e5325 --- /dev/null +++ b/docs/the_black_code_style/index.md @@ -0,0 +1,54 @@ +# The Black Code Style + +```{toctree} +--- +hidden: +--- + +Current style +Future style +``` + +_Black_ is a PEP 8 compliant opinionated formatter with its own style. + +While keeping the style unchanged throughout releases has always been a goal, the +_Black_ code style isn't set in stone. It evolves to accommodate for new features in the +Python language and, occasionally, in response to user feedback. Large-scale style +preferences presented in {doc}`current_style` are very unlikely to change, but minor +style aspects and details might change according to the stability policy presented +below. Ongoing style considerations are tracked on GitHub with the +[style](https://github.com/psf/black/labels/T%3A%20style) issue label. + +(labels/stability-policy)= + +## Stability Policy + +The following policy applies for the _Black_ code style, in non pre-release versions of +_Black_: + +- If code has been formatted with _Black_, it will remain unchanged when formatted with + the same options using any other release in the same calendar year. + + This means projects can safely use `black ~= 26.0` without worrying about formatting + changes disrupting their project in 2026. We may still fix bugs where _Black_ crashes + on some code, and make other improvements that do not affect formatting. + + In rare cases, we may make changes affecting code that has not been previously + formatted with _Black_. For example, we have had bugs where we accidentally removed + some comments. Such bugs can be fixed without breaking the stability policy. + +- The first release in a new calendar year _may_ contain formatting changes, although + these will be minimised as much as possible. This is to allow for improved formatting + enabled by newer Python language syntax as well as due to improvements in the + formatting logic. + +- The `--preview` and `--unstable` flags are exempt from this policy. There are no + guarantees around the stability of the output with these flags passed into _Black_. + They are intended for allowing experimentation with proposed changes to the _Black_ + code style. The `--preview` style at the end of a year should closely match the stable + style for the next year, but we may always make changes. + +Documentation for both the current and future styles can be found: + +- {doc}`current_style` +- {doc}`future_style` diff --git a/docs/usage_and_configuration/black_as_a_server.md b/docs/usage_and_configuration/black_as_a_server.md new file mode 100644 index 0000000..1bd4d56 --- /dev/null +++ b/docs/usage_and_configuration/black_as_a_server.md @@ -0,0 +1,116 @@ +# Black as a server (blackd) + +`blackd` is a small HTTP server that exposes _Black_'s functionality over a simple +protocol. The main benefit of using it is to avoid the cost of starting up a new _Black_ +process every time you want to blacken a file. + +```{warning} +`blackd` should not be run as a publicly accessible server as there are no security +precautions in place to prevent abuse. **It is intended for local use only**. +``` + +## Usage + +`blackd` is not packaged alongside _Black_ by default because it has additional +dependencies. You will need to execute `pip install 'black[d]'` to install it. + +You can start the server on the default port, binding only to the local interface by +running `blackd`. You will see a single line mentioning the server's version, and the +host and port it's listening on. `blackd` will then print an access log similar to most +web servers on standard output, merged with any exception traces caused by invalid +formatting requests. + +`blackd` provides even less options than _Black_. You can see them by running +`blackd --help`: + +```{program-output} blackd --help + +``` + +You can test that blackd is working using `curl`: + +```sh +blackd --bind-port 9090 & # or let blackd choose a port +curl -s -XPOST "localhost:9090" -d "print('valid')" +``` + +Or using the python client: + +```python +import asyncio + +from blackd.client import BlackDClient + +async def main(): + client = BlackDClient(url="http://127.0.0.1:9090") + unformatted_code = "def hello(): print('Hello, World!')" + formatted_code = await client.format_code(unformatted_code) + print(formatted_code) + +if __name__ == "__main__": + asyncio.run(main()) +``` + +Cross-origin browser requests are rejected by default. If you need to access `blackd` +from a browser-based client, pass one or more `--cors-allow-origin` options to allow +specific origins. + +## Protocol + +`blackd` only accepts `POST` requests at the `/` path. The body of the request should +contain the python source code to be formatted, encoded according to the `charset` field +in the `Content-Type` request header. If no `charset` is specified, `blackd` assumes +`UTF-8`. Request bodies are limited to 5 MiB by default; use `--max-body-size` to change +that limit. + +There are a few HTTP headers that control how the source code is formatted. These +correspond to command line flags for _Black_. There is one exception to this: +`X-Protocol-Version` which if present, should have the value `1`, otherwise the request +is rejected with `HTTP 501` (Not Implemented). + +The headers controlling how source code is formatted are: + +- `X-Line-Length`: corresponds to the `--line-length` command line flag. +- `X-Skip-Source-First-Line`: corresponds to the `--skip-source-first-line` command line + flag. If present and its value is not an empty string, the first line of the source + code will be ignored. +- `X-Skip-String-Normalization`: corresponds to the `--skip-string-normalization` + command line flag. If present and its value is not the empty string, no string + normalization will be performed. +- `X-Skip-Magic-Trailing-Comma`: corresponds to the `--skip-magic-trailing-comma` + command line flag. If present and its value is not an empty string, trailing commas + will not be used as a reason to split lines. +- `X-Preview`: corresponds to the `--preview` command line flag. If present and its + value is not an empty string, experimental and potentially disruptive style changes + will be used. +- `X-Unstable`: corresponds to the `--unstable` command line flag. If present and its + value is not an empty string, experimental style changes that are known to be buggy + will be used. +- `X-Enable-Unstable-Feature`: corresponds to the `--enable-unstable-feature` flag. The + contents of the flag must be a comma-separated list of unstable features to be + enabled. Example: `X-Enable-Unstable-Feature: feature1, feature2`. +- `X-Fast-Or-Safe`: if set to `fast`, `blackd` will act as _Black_ does when passed the + `--fast` command line flag. +- `X-Python-Variant`: if set to `pyi`, `blackd` will act as _Black_ does when passed the + `--pyi` command line flag. Otherwise, its value must correspond to a Python version or + a set of comma-separated Python versions, optionally prefixed with `py`. For example, + to request code that is compatible with Python 3.5 and 3.6, set the header to + `py3.5,py3.6`. +- `X-Diff`: corresponds to the `--diff` command line flag. If present, a diff of the + formats will be output. + +If any of these headers are set to invalid values, `blackd` returns a `HTTP 400` error +response, mentioning the name of the problematic header in the message body. + +Apart from the above, `blackd` can produce the following response codes: + +- `HTTP 204`: If the input is already well-formatted. The response body is empty. +- `HTTP 200`: If formatting was needed on the input. The response body contains the + blackened Python code, and the `Content-Type` header is set accordingly. +- `HTTP 400`: If the input contains a syntax error. Details of the error are returned in + the response body. +- `HTTP 500`: If there was any other kind of error while trying to format the input. The + response body contains a textual representation of the error. + +The response headers include a `X-Black-Version` header containing the version of +_Black_. diff --git a/docs/usage_and_configuration/black_docker_image.md b/docs/usage_and_configuration/black_docker_image.md new file mode 100644 index 0000000..72969b7 --- /dev/null +++ b/docs/usage_and_configuration/black_docker_image.md @@ -0,0 +1,53 @@ +# Black Docker image + +Official _Black_ Docker images are available on +[Docker Hub](https://hub.docker.com/r/pyfound/black). + +_Black_ images with the following tags are available: + +- release numbers, e.g. `21.5b2`, `21.6b0`, `21.7b0` etc.\ + ℹ Recommended for users who want to use a particular version of _Black_. +- `latest_release` - tag created when a new version of _Black_ is released.\ + ℹ Recommended for users who want to use released versions of _Black_. It maps to + [the latest release](https://github.com/psf/black/releases/latest) of _Black_. +- `latest_prerelease` - tag created when a new alpha (prerelease) version of _Black_ is + released.\ + ℹ Recommended for users who want to preview or test alpha versions of _Black_. Note + that the most recent release may be newer than any prerelease, because no prereleases + are created before most releases. +- `latest` - tag used for the newest image of _Black_.\ + ℹ Recommended for users who always want to use the latest version of _Black_, even + before it is released. + +There is one more tag used for _Black_ Docker images - `latest_non_release`. It is +created for all unreleased +[commits on the `main` branch](https://github.com/psf/black/commits/main). This tag is +not meant to be used by external users. + +From version 23.11.0 the Docker image installs a compiled black into the image. + +## Usage + +A permanent container doesn't have to be created to use _Black_ as a Docker image. It's +enough to run _Black_ commands for the chosen image denoted as `:tag`. In the below +examples, the `latest_release` tag is used. If `:tag` is omitted, the `latest` tag will +be used. + +More about _Black_ usage can be found in +[Usage and Configuration: The basics](./the_basics.md). + +### Check Black version + +```console +$ docker run --rm pyfound/black:latest_release black --version +``` + +### Check code + +```console +$ docker run --rm --volume $(pwd):/src --workdir /src pyfound/black:latest_release black --check . +``` + +_Remark_: besides [regular _Black_ exit codes](./the_basics.md) returned by `--check` +option, [Docker exit codes](https://docs.docker.com/engine/reference/run/#exit-status) +should also be considered. diff --git a/docs/usage_and_configuration/file_collection_and_discovery.md b/docs/usage_and_configuration/file_collection_and_discovery.md new file mode 100644 index 0000000..6d17f4d --- /dev/null +++ b/docs/usage_and_configuration/file_collection_and_discovery.md @@ -0,0 +1,49 @@ +# File collection and discovery + +You can directly pass _Black_ files, but you can also pass directories and _Black_ will +walk them, collecting files to format. It determines what files to format or skip +automatically using the inclusion and exclusion regexes and as well their modification +time. + +## Ignoring unmodified files + +_Black_ remembers files it has already formatted, unless the `--diff` flag is used or +code is passed via standard input. This information is stored per-user. The exact +location of the file depends on the _Black_ version and the system on which _Black_ is +run. The file is non-portable. The standard location on common operating systems is: + +- Windows: + `C:\Users\\AppData\Local\black\black\Cache\\cache...pickle` +- macOS: + `/Users//Library/Caches/black//cache...pickle` +- Linux: + `/home//.cache/black//cache...pickle` + +`file-mode` is an int flag that determines whether the file was formatted as 3.6+ only, +as .pyi, and whether string normalization was omitted. + +To override the location of these files on all systems, set the environment variable +`BLACK_CACHE_DIR` to the preferred location. Alternatively on macOS and Linux, set +`XDG_CACHE_HOME` to your preferred location. For example, if you want to put the cache +in the directory you're running _Black_ from, set `BLACK_CACHE_DIR=.cache/black`. +_Black_ will then write the above files to `.cache/black`. Note that `BLACK_CACHE_DIR` +will take precedence over `XDG_CACHE_HOME` if both are set. + +### Disabling the cache with --no-cache + +If you need Black to always perform a fresh analysis and not consult or update the +on-disk cache, use the `--no-cache` flag. When provided, Black will neither read from +nor write to the per-user cache. This is useful for debugging, for CI runs where you +want a deterministic fresh run, or when you suspect cache corruption. + +Example: + +python -m black --no-cache . + +## .gitignore + +If `--exclude` is not set, _Black_ will automatically ignore files and directories in +`.gitignore` file(s), if present. + +If you want _Black_ to continue using `.gitignore` while also configuring the exclusion +rules, please use `--extend-exclude`. diff --git a/docs/usage_and_configuration/index.md b/docs/usage_and_configuration/index.md new file mode 100644 index 0000000..1c86a49 --- /dev/null +++ b/docs/usage_and_configuration/index.md @@ -0,0 +1,28 @@ +# Usage and Configuration + +```{toctree} +--- +hidden: +--- + +the_basics +file_collection_and_discovery +black_as_a_server +black_docker_image +``` + +Sometimes, running _Black_ with its defaults and passing filepaths to it just won't cut +it. Passing each file using paths will become burdensome, and maybe you would like +_Black_ to not touch your files and just output diffs. And yes, you _can_ tweak certain +parts of _Black_'s style, but please know that configurability in this area is +purposefully limited. + +Using many of these more advanced features of _Black_ will require some configuration. +Configuration that will either live on the command line or in a TOML configuration file. + +This section covers features of _Black_ and configuring _Black_ in detail: + +- {doc}`The basics <./the_basics>` +- {doc}`File collection and discovery ` +- {doc}`Black as a server (blackd) <./black_as_a_server>` +- {doc}`Black Docker image <./black_docker_image>` diff --git a/docs/usage_and_configuration/the_basics.md b/docs/usage_and_configuration/the_basics.md new file mode 100644 index 0000000..69faa24 --- /dev/null +++ b/docs/usage_and_configuration/the_basics.md @@ -0,0 +1,604 @@ +# The basics + +Foundational knowledge on using and configuring Black. + +_Black_ is a well-behaved Unix-style command-line tool: + +- it does nothing if it finds no sources to format; +- it will read from standard input and write to standard output if `-` is used as the + filename; +- it only outputs messages to users on standard error; +- exits with code 0 unless an internal error occurred or a CLI option prompted it. + +## Usage + +_Black_ will reformat entire files in place. To get started right away with sensible +defaults: + +```sh +black {source_file_or_directory} +``` + +You can run _Black_ as a package if running it as a script doesn't work: + +```sh +python -m black {source_file_or_directory} +``` + +### Ignoring sections + +Black will not reformat lines that contain `# fmt: skip` or blocks that start with +`# fmt: off` and end with `# fmt: on`. `# fmt: skip` can be mixed with other +pragmas/comments either with multiple comments (e.g. `# fmt: skip # pylint # noqa`) or +as a semicolon separated list (e.g. `# fmt: skip; pylint; noqa`). `# fmt: on/off` must +be on the same level of indentation and in the same block, meaning no unindents beyond +the initial indentation level between them. Black also recognizes +[YAPF](https://github.com/google/yapf)'s block comments to the same effect, as a +courtesy for straddling code. + +### Command line options + +The CLI options of _Black_ can be displayed by running `black --help`. All options are +also covered in more detail below. + +While _Black_ has quite a few knobs these days, it is still opinionated so style options +are deliberately limited and rarely added. + +Note that all command-line options listed above can also be configured using a +`pyproject.toml` file (more on that below). + +#### `-h`, `--help` + +Show available command-line options and exit. + +#### `-c`, `--code` + +Format the code passed in as a string. + +```console +$ black --code "print ( 'hello, world' )" +print("hello, world") +``` + +#### `-l`, `--line-length` + +How many characters per line to allow. The default is 88. + +See also [the style documentation](labels/line-length). + +#### `-t`, `--target-version` + +Python versions that should be supported by Black's output. You can run `black --help` +and look for the `--target-version` option to see the full list of supported versions. +You should include all versions that your code supports. If you support Python 3.11 +through 3.13, you should write: + +```console +$ black -t py311 -t py312 -t py313 +``` + +In a [configuration file](#configuration-via-a-file), you can write: + +```toml +target-version = ["py311", "py312", "py313"] +``` + +By default, Black will infer target versions from the project metadata in +`pyproject.toml`, specifically the `[project.requires-python]` field. If this does not +yield conclusive results, Black will use per-file auto-detection. + +_Black_ uses this option to decide what grammar to use to parse your code. In addition, +it may use it to decide what style to use. For example, support for a trailing comma +after `*args` in a function call was added in Python 3.5, so _Black_ will add this comma +only if the target versions are all Python 3.5 or higher: + +```console +$ black --line-length=10 --target-version=py35 -c 'f(a, *args)' +f( + a, + *args, +) +$ black --line-length=10 --target-version=py34 -c 'f(a, *args)' +f( + a, + *args +) +$ black --line-length=10 --target-version=py34 --target-version=py35 -c 'f(a, *args)' +f( + a, + *args +) +``` + +#### `--pyi` + +Format all input files like typing stubs regardless of file extension. This is useful +when piping source on standard input. + +#### `--ipynb` + +Format all input files like Jupyter Notebooks regardless of file extension. This is +useful when piping source on standard input. + +#### `--python-cell-magics` + +When processing Jupyter Notebooks, add the given magic to the list of known python- +magics. Useful for formatting cells with custom python magics. See the +[Jupyter Notebooks guide](../guides/using_black_with_jupyter_notebooks.md) for more +details. + +#### `-x, --skip-source-first-line` + +Skip the first line of the source code. + +#### `-S, --skip-string-normalization` + +By default, _Black_ uses double quotes for all strings and normalizes string prefixes, +as described in [the style documentation](labels/strings). If this option is given, +strings are left unchanged instead. + +#### `-C, --skip-magic-trailing-comma` + +By default, _Black_ uses existing trailing commas as an indication that short lines +should be left separate, as described in +[the style documentation](labels/magic-trailing-comma). If this option is given, the +magic trailing comma is ignored. + +#### `--preview` + +Enable potentially disruptive style changes that we expect to add to Black's main +functionality in the next major release. Use this if you want a taste of what next +year's style will look like. + +Read more about [our preview style](labels/preview-style). + +There is no guarantee on the code style produced by this flag across releases. + +#### `--unstable` + +Enable all style changes in `--preview`, plus additional changes that we would like to +make eventually, but that have known issues that need to be fixed before they can move +back to the `--preview` style. Use this if you want to experiment with these changes and +help fix issues with them. + +There is no guarantee on the code style produced by this flag across releases. + +#### `--enable-unstable-feature` + +Enable specific features from the `--unstable` style. See +[the preview style documentation](labels/unstable-features) for the list of supported +features. This flag can only be used when `--preview` is enabled. Users are encouraged +to use this flag if they use `--preview` style and a feature that affects their code is +moved from the `--preview` to the `--unstable` style, but they want to avoid the thrash +from undoing this change. + +There are no guarantees on the behavior of these features, or even their existence, +across releases. + +(labels/exit-code)= + +#### `--check` + +Don't write the files back, just return the status. _Black_ will exit with: + +- code 0 if nothing would change; +- code 1 if some files would be reformatted; or +- code 123 if there was an internal error + +If used in combination with `--quiet` then only the exit code will be returned, unless +there was an internal error. + +```console +$ black test.py --check +All done! ✨ 🍰 ✨ +1 file would be left unchanged. +$ echo $? +0 + +$ black test.py --check +would reformat test.py +Oh no! 💥 💔 💥 +1 file would be reformatted. +$ echo $? +1 + +$ black test.py --check +error: cannot format test.py: INTERNAL ERROR: Black produced code that is not equivalent to the source. Please report a bug on https://github.com/psf/black/issues. This diff might be helpful: /tmp/blk_kjdr1oog.log +Oh no! 💥 💔 💥 +1 file would fail to reformat. +$ echo $? +123 +``` + +#### `--diff` + +Don't write the files back, just output a diff to indicate what changes _Black_ would've +made. They are printed to stdout so capturing them is simple. + +If you'd like colored diffs, you can enable them with `--color`. + +```console +$ black test.py --diff +--- test.py 2021-03-08 22:23:40.848954+00:00 ++++ test.py 2021-03-08 22:23:47.126319+00:00 +@@ -1 +1 @@ +-print ( 'hello, world' ) ++print("hello, world") +would reformat test.py +All done! ✨ 🍰 ✨ +1 file would be reformatted. +``` + +#### `--no-cache` + +Do not consult or update Black's per-user cache during this run. When `--no-cache` is +specified, Black will perform fresh analysis for all files and will neither read from +nor write to the cache. This is helpful for reproducing formatting results from a clean +run, debugging cache-related issues, or ensuring CI executes a fresh formatting analysis +every time. + +#### `--color` / `--no-color` + +Show (or do not show) colored diff. Only applies when `--diff` is given. + +#### `--line-ranges` + +When specified, _Black_ will try its best to only format these lines. + +This option can be specified multiple times, and a union of the lines will be formatted. +Each range must be specified as two integers connected by a `-`: `-`. The +`` and `` integer indices are 1-based and inclusive on both ends. + +_Black_ may still format lines outside of the ranges for multi-line statements. +Formatting more than one file or any Jupyter Notebooks with this option is not +supported. This option cannot be specified in the `pyproject.toml` config. + +Example: `black --line-ranges=1-10 --line-ranges=21-30 test.py` will format lines from +`1` to `10` and `21` to `30`. + +This option is mainly for editor integrations, such as "Format Selection". + +```{note} +Due to [#4052](https://github.com/psf/black/issues/4052), `--line-ranges` might format +extra lines outside of the ranges when there are unformatted lines with the exact +formatted content next to the requested lines. It also disables _Black_'s formatting +stability check in `--safe` mode. +``` + +#### `--fast` / `--safe` + +By default, _Black_ performs [an AST safety check](labels/ast-changes) after formatting +your code. The `--fast` flag turns off this check and the `--safe` flag explicitly +enables it. + +#### `--required-version` + +Require a specific version of _Black_ to be running. This is useful for ensuring that +all contributors to your project are using the same version, because different versions +of _Black_ may format code a little differently. This option can be set in a +configuration file for consistent results across environments. + +```console +$ black --version +black, 26.5.1 (compiled: yes) +$ black --required-version 26.5.1 -c "format = 'this'" +format = "this" +$ black --required-version 31.5b2 -c "still = 'beta?!'" +Oh no! 💥 💔 💥 The required version does not match the running version! +``` + +You can also pass just the major version: + +```console +$ black --required-version 22 -c "format = 'this'" +format = "this" +$ black --required-version 31 -c "still = 'beta?!'" +Oh no! 💥 💔 💥 The required version does not match the running version! +``` + +Because of our [stability policy](../the_black_code_style/index.md), this will guarantee +stable formatting, but still allow you to take advantage of improvements that do not +affect formatting. + +#### `--exclude` + +A regular expression that matches files and directories that should be excluded on +recursive searches. An empty value means no paths are excluded. Use forward slashes for +directories on all platforms (Windows, too). By default, Black also ignores all paths +listed in `.gitignore`. Changing this value will override all default exclusions. + +Default Exclusions: +`['.direnv', '.eggs', '.git', '.hg', '.ipynb_checkpoints', '.mypy_cache', '.nox', '.pytest_cache', '.ruff_cache', '.tox', '.svn', '.venv', '.vscode', '__pypackages__', '_build', 'buck-out', 'build', 'dist', 'venv'] ` + +If the regular expression contains newlines, it is treated as a +[verbose regular expression](https://docs.python.org/3/library/re.html#re.VERBOSE). This +is typically useful when setting these options in a `pyproject.toml` configuration file; +see [Configuration format](#configuration-format) for more information. + +#### `--extend-exclude` + +Like `--exclude`, but adds additional files and directories on top of the default values +instead of overriding them. + +#### `--force-exclude` + +Like `--exclude`, but files and directories matching this regex will be excluded even +when they are passed explicitly as arguments. This is useful when invoking Black +programmatically on changed files, such as in a pre-commit hook or editor plugin. + +#### `--stdin-filename` + +The name of the file when passing it through stdin. Useful to make sure Black will +respect the `--force-exclude` option on some editors that rely on using stdin. + +#### `--include` + +A regular expression that matches files and directories that should be included on +recursive searches. An empty value means all files are included regardless of the name. +Use forward slashes for directories on all platforms (Windows, too). Overrides all +exclusions, including from `.gitignore` and command line options. + +Default Inclusions: `['.pyi', '.ipynb']` + +#### `-W`, `--workers` + +When _Black_ formats multiple files, it may use a process pool to speed up formatting. +This option controls the number of parallel workers. This can also be specified via the +`BLACK_NUM_WORKERS` environment variable. Defaults to the number of CPUs in the system. + +#### `-q`, `--quiet` + +Stop emitting all non-critical output. Error messages will still be emitted (which can +silenced by `2>/dev/null`). + +```console +$ black src/ -q +error: cannot format src/black_primer/cli.py: Cannot parse: 5:6 + mport asyncio + ^ +ParseError: bad input +``` + +#### `-v`, `--verbose` + +Emit messages about files that were not changed or were ignored due to exclusion +patterns. If _Black_ is using a configuration file, a message detailing which one it is +using will be emitted. + +```console +$ black src/ -v +Using configuration from /tmp/pyproject.toml. +src/blib2to3 ignored: matches the --extend-exclude regular expression +src/_black_version.py wasn't modified on disk since last run. +src/black/__main__.py wasn't modified on disk since last run. +error: cannot format src/black_primer/cli.py: Cannot parse: 5:6 + mport asyncio + ^ +ParseError: bad input +reformatted src/black_primer/lib.py +reformatted src/blackd/__init__.py +reformatted src/black/__init__.py +Oh no! 💥 💔 💥 +3 files reformatted, 2 files left unchanged, 1 file failed to reformat +``` + +#### `--version` + +You can check the version of _Black_ you have installed using the `--version` flag. + +```console +$ black --version +black, 26.5.1 +``` + +#### `--config` + +Read configuration options from a configuration file. See +[below](#configuration-via-a-file) for more details on the configuration file. + +### Environment variable options + +_Black_ supports the following configuration via environment variables. + +#### `BLACK_CACHE_DIR` + +The directory where _Black_ should store its cache. + +#### `BLACK_NUM_WORKERS` + +The number of parallel workers _Black_ should use. The command line option `-W` / +`--workers` takes precedence over this environment variable. + +### Code input alternatives + +_Black_ supports formatting code via stdin, with the result being printed to stdout. +Just let _Black_ know with `-` as the path. + +```console +$ echo "print ( 'hello, world' )" | black - +print("hello, world") +reformatted - +All done! ✨ 🍰 ✨ +1 file reformatted. +``` + +**Tip:** if you need _Black_ to treat stdin input as a file passed directly via the CLI, +use `--stdin-filename`. Useful to make sure _Black_ will respect the `--force-exclude` +option on some editors that rely on using stdin. + +You can also pass code as a string using the `--code` option. + +### Writeback and reporting + +By default _Black_ reformats the files given and/or found in place. Sometimes you need +_Black_ to just tell you what it _would_ do without actually rewriting the Python files. + +There's two variations to this mode that are independently enabled by their respective +flags: + +- `--check` (exit with code 1 if any file would be reformatted) +- `--diff` (print a diff instead of reformatting files) + +Both variations can be enabled at once. + +### Output verbosity + +_Black_ in general tries to produce the right amount of output, balancing between +usefulness and conciseness. By default, _Black_ emits files modified and error messages, +plus a short summary. + +```console +$ black src/ +error: cannot format src/black_primer/cli.py: Cannot parse: 5:6 + mport asyncio + ^ +ParseError: bad input +reformatted src/black_primer/lib.py +reformatted src/blackd/__init__.py +reformatted src/black/__init__.py +Oh no! 💥 💔 💥 +3 files reformatted, 2 files left unchanged, 1 file failed to reformat. +``` + +The `--quiet` and `--verbose` flags control output verbosity. + +## Configuration via a file + +_Black_ is able to read project-specific default values for its command line options +from a `pyproject.toml` file. This is especially useful for specifying custom +`--include` and `--exclude`/`--force-exclude`/`--extend-exclude` patterns for your +project. + +**Pro-tip**: If you're asking yourself "Do I need to configure anything?" the answer is +"No". _Black_ is all about sensible defaults. Applying those defaults will have your +code in compliance with many other _Black_ formatted projects. + +### What on Earth is a `pyproject.toml` file? + +[PEP 518](https://peps.python.org/pep-0518/) defines `pyproject.toml` as a configuration +file to store build system requirements for Python projects. With the help of tools like +[Poetry](https://python-poetry.org/), [Flit](https://flit.pypa.io/), or +[Hatch](https://hatch.pypa.io/) it can fully replace the need for `setup.py` and +`setup.cfg` files. + +### Where _Black_ looks for the file + +By default _Black_ looks for `pyproject.toml` containing a `[tool.black]` section +starting from the common base directory of all files and directories passed on the +command line. If it's not there, it looks in parent directories. It stops looking when +it finds the file, or a `.git` directory, or a `.hg` directory, or the root of the file +system, whichever comes first. + +If you're formatting standard input, _Black_ will look for configuration starting from +the current working directory. + +You can use a "global" configuration, stored in a specific location in your home +directory. This will be used as a fallback configuration, that is, it will be used if +and only if _Black_ doesn't find any configuration as mentioned above. Depending on your +operating system, this configuration file should be stored as: + +- Windows: `~\.black` +- Unix-like (Linux, macOS, etc.): `$XDG_CONFIG_HOME/black` (`~/.config/black` if the + `XDG_CONFIG_HOME` environment variable is not set) + +Note that these are paths to the TOML file itself (meaning that they shouldn't be named +as `pyproject.toml`), not directories where you store the configuration (i.e., +`black`/`.black` is the file to create and add your configuration options to, in the +`~/.config/` directory). Here, `~` refers to the path to your home directory. On +Windows, this will be something like `C:\Users\UserName` and stored in the environment +variable `%USERPROFILE%`. + +You can also explicitly specify the path to a particular file that you want with +`--config`. In this situation _Black_ will not look for any other file. + +If you're running with `--verbose`, you will see a message if a file was found and used. + +Please note `blackd` will not use `pyproject.toml` configuration. + +### Configuration format + +As the file extension suggests, `pyproject.toml` is a [TOML](https://toml.io) file. It +contains separate sections for different tools. _Black_ is using the `[tool.black]` +section. The option keys are the same as long names of options on the command line. + +Most command-line options can be configured in `[tool.black]` by using their long name +without the leading `--` (for example, `--line-length` becomes `line-length`). Options +that cannot be configured in `pyproject.toml` are called out explicitly in the option +reference above. + +Note that you have to use single-quoted strings in TOML for regular expressions. It's +the equivalent of r-strings in Python. Multiline strings are treated as verbose regular +expressions by Black. Use `[ ]` to denote a significant space character. + +
+Example pyproject.toml + +```toml +[tool.black] +line-length = 88 +target-version = ['py37'] +include = '\.pyi?$' +# 'extend-exclude' excludes files or directories in addition to the defaults +extend-exclude = ''' +# A regex preceded with ^/ will apply only to files and directories +# in the root of the project. +( + ^/foo.py # exclude a file named foo.py in the root of the project + | .*_pb2.py # exclude autogenerated Protocol Buffer files anywhere in the project +) +''' +``` + +
+ +
+More complete pyproject.toml template + +```toml +[tool.black] +line-length = 88 +target-version = ["py311"] +required-version = "26" +include = '\.pyi?$' + +# Formatting behavior +skip-string-normalization = false +skip-magic-trailing-comma = false +preview = false +unstable = false + +# File collection +extend-exclude = ''' +( + ^/foo.py + | .*_pb2.py +) +''' +force-exclude = ''' +( + ^/generated/ +) +''' +``` + +
+ +### Lookup hierarchy + +Command-line options have defaults that you can see in `--help`. A `pyproject.toml` can +override those defaults. Finally, options provided by the user on the command line +override both. + +_Black_ will only ever use one `pyproject.toml` file during an entire run. It doesn't +look for multiple files, and doesn't compose configuration from different levels of the +file hierarchy. + +## Next steps + +A good next step would be configuring auto-discovery so `black .` is all you need +instead of laboriously listing every file or directory. You can get started by heading +over to [File collection and discovery](./file_collection_and_discovery.md). + +Another good choice would be setting up an +[integration with your editor](../integrations/editors.md) of choice or with +[pre-commit for source version control](../integrations/source_version_control.md). diff --git a/plugin/black.vim b/plugin/black.vim new file mode 100644 index 0000000..db6b566 --- /dev/null +++ b/plugin/black.vim @@ -0,0 +1,94 @@ +" black.vim +" Author: Łukasz Langa +" Created: Mon Mar 26 23:27:53 2018 -0700 +" Requires: Vim Ver7.0+ +" Version: 1.2 +" +" Documentation: +" This plugin formats Python files. +" +" History: +" 1.0: +" - initial version +" 1.1: +" - restore cursor/window position after formatting +" 1.2: +" - use autoload script + +if exists("g:load_black") + finish +endif + +if v:version < 700 || !has('python3') + func! __ERROR() + let messages = [] + + if v:version < 700 + call add(messages, "vim7.0+") + endif + if !has('python3') + call add(messages, "Python 3.10 support") + endif + + echo "The black.vim plugin requires" join(messages, " and ") + endfunc + command! Black :call __ERROR() + command! BlackUpgrade :call __ERROR() + command! BlackVersion :call __ERROR() + finish +endif + +let g:load_black = "py1.0" +if !exists("g:black_virtualenv") + if has("nvim") + let g:black_virtualenv = "~/.local/share/nvim/black" + else + let g:black_virtualenv = "~/.vim/black" + endif +endif +if !exists("g:black_fast") + let g:black_fast = 0 +endif +if !exists("g:black_linelength") + let g:black_linelength = 88 +endif +if !exists("g:black_skip_string_normalization") + if exists("g:black_string_normalization") + let g:black_skip_string_normalization = !g:black_string_normalization + else + let g:black_skip_string_normalization = 0 + endif +endif +if !exists("g:black_skip_magic_trailing_comma") + if exists("g:black_magic_trailing_comma") + let g:black_skip_magic_trailing_comma = !g:black_magic_trailing_comma + else + let g:black_skip_magic_trailing_comma = 0 + endif +endif +if !exists("g:black_quiet") + let g:black_quiet = 0 +endif +if !exists("g:black_target_version") + let g:black_target_version = "" +endif +if !exists("g:black_use_virtualenv") + let g:black_use_virtualenv = 1 +endif +if !exists("g:black_preview") + let g:black_preview = 0 +endif + +function BlackComplete(ArgLead, CmdLine, CursorPos) + return [ +\ 'target_version=py310', +\ 'target_version=py311', +\ 'target_version=py312', +\ 'target_version=py313', +\ 'target_version=py314', +\ ] +endfunction + +command! -nargs=* -complete=customlist,BlackComplete Black :call black#Black() +command! BlackUpgrade :call black#BlackUpgrade() +command! BlackVersion :call black#BlackVersion() diff --git a/profiling/dict_big.py b/profiling/dict_big.py new file mode 100644 index 0000000..f330ac5 --- /dev/null +++ b/profiling/dict_big.py @@ -0,0 +1,8001 @@ +config = some.Structure( + some_mapping={ + "00501": "AB890X", + "00544": "AB890X", + "01001": "AB889X", + "01002": "AB889X", + "01003": "AB889X", + "01004": "AB889X", + "01005": "AB889X", + "01007": "AB889X", + "01008": "AB889X", + "01009": "AB889X", + "01010": "AB889X", + "01011": "AB889X", + "01012": "AB889X", + "01013": "AB889X", + "01014": "AB889X", + "01020": "AB889X", + "01021": "AB889X", + "01022": "AB889X", + "01026": "AB889X", + "01027": "AB889X", + "01028": "AB889X", + "01029": "AB889X", + "01030": "AB889X", + "01031": "AB889X", + "01032": "AB889X", + "01033": "AB889X", + "01034": "AB889X", + "01035": "AB889X", + "01036": "AB889X", + "01037": "AB889X", + "01038": "AB889X", + "01039": "AB889X", + "01040": "AB889X", + "01041": "AB889X", + "01050": "AB889X", + "01053": "AB889X", + "01054": "AB889X", + "01056": "AB889X", + "01057": "AB889X", + "01059": "AB889X", + "01060": "AB889X", + "01061": "AB889X", + "01062": "AB889X", + "01063": "AB889X", + "01066": "AB889X", + "01068": "AB889X", + "01069": "AB889X", + "01070": "AB889X", + "01071": "AB889X", + "01072": "AB889X", + "01073": "AB889X", + "01074": "AB889X", + "01075": "AB889X", + "01077": "AB889X", + "01079": "AB889X", + "01080": "AB889X", + "01081": "AB889X", + "01082": "AB889X", + "01083": "AB889X", + "01084": "AB889X", + "01085": "AB889X", + "01086": "AB889X", + "01088": "AB889X", + "01089": "AB889X", + "01090": "AB889X", + "01092": "AB889X", + "01093": "AB889X", + "01094": "AB889X", + "01095": "AB889X", + "01096": "AB889X", + "01097": "AB889X", + "01098": "AB889X", + "01101": "AB889X", + "01102": "AB889X", + "01103": "AB889X", + "01104": "AB889X", + "01105": "AB889X", + "01106": "AB889X", + "01107": "AB889X", + "01108": "AB889X", + "01109": "AB889X", + "01111": "AB889X", + "01115": "AB889X", + "01116": "AB889X", + "01118": "AB889X", + "01119": "AB889X", + "01128": "AB889X", + "01129": "AB889X", + "01133": "AB889X", + "01138": "AB889X", + "01139": "AB889X", + "01144": "AB889X", + "01151": "AB889X", + "01152": "AB889X", + "01195": "AB889X", + "01199": "AB889X", + "01201": "AB890X", + "01202": "AB889X", + "01203": "AB889X", + "01220": "AB890X", + "01222": "AB889X", + "01223": "AB889X", + "01224": "AB889X", + "01225": "AB889X", + "01226": "AB889X", + "01227": "AB889X", + "01229": "AB889X", + "01230": "AB889X", + "01235": "AB889X", + "01236": "AB889X", + "01237": "AB889X", + "01238": "AB889X", + "01240": "AB889X", + "01242": "AB889X", + "01243": "AB889X", + "01244": "AB889X", + "01245": "AB889X", + "01247": "AB890X", + "01252": "AB889X", + "01253": "AB889X", + "01254": "AB889X", + "01255": "AB889X", + "01256": "AB889X", + "01257": "AB890X", + "01258": "AB889X", + "01259": "AB889X", + "01260": "AB889X", + "01262": "AB889X", + "01263": "AB889X", + "01264": "AB889X", + "01266": "AB889X", + "01267": "AB890X", + "01270": "AB889X", + "01301": "AB889X", + "01302": "AB889X", + "01330": "AB889X", + "01331": "AB889X", + "01337": "AB889X", + "01338": "AB889X", + "01339": "AB889X", + "01340": "AB889X", + "01341": "AB889X", + "01342": "AB889X", + "01343": "AB889X", + "01344": "AB889X", + "01346": "AB889X", + "01347": "AB889X", + "01349": "AB889X", + "01350": "AB889X", + "01351": "AB889X", + "01354": "AB889X", + "01355": "AB889X", + "01360": "AB889X", + "01364": "AB889X", + "01366": "AB889X", + "01367": "AB890X", + "01368": "AB889X", + "01370": "AB889X", + "01373": "AB889X", + "01375": "AB889X", + "01376": "AB889X", + "01378": "AB889X", + "01379": "AB889X", + "01380": "AB889X", + "01420": "AB889X", + "01430": "AB889X", + "01431": "AB889X", + "01432": "AB889X", + "01434": "AB889X", + "01436": "AB889X", + "01438": "AB889X", + "01440": "AB889X", + "01441": "AB889X", + "01450": "AB889X", + "01451": "AB889X", + "01452": "AB889X", + "01453": "AB889X", + "01460": "AB889X", + "01462": "AB889X", + "01463": "AB889X", + "01464": "AB889X", + "01467": "AB889X", + "01468": "AB889X", + "01469": "AB889X", + "01470": "AB889X", + "01471": "AB889X", + "01472": "AB889X", + "01473": "AB889X", + "01474": "AB889X", + "01475": "AB889X", + "01477": "AB889X", + "01501": "AB889X", + "01503": "AB889X", + "01504": "AB889X", + "01505": "AB889X", + "01506": "AB889X", + "01507": "AB889X", + "01508": "AB889X", + "01509": "AB889X", + "01510": "AB889X", + "01515": "AB889X", + "01516": "AB889X", + "01517": "AB889X", + "01518": "AB889X", + "01519": "AB889X", + "01520": "AB889X", + "01521": "AB889X", + "01522": "AB889X", + "01523": "AB889X", + "01524": "AB889X", + "01525": "AB889X", + "01526": "AB889X", + "01527": "AB889X", + "01529": "AB889X", + "01531": "AB889X", + "01532": "AB889X", + "01534": "AB889X", + "01535": "AB889X", + "01536": "AB889X", + "01537": "AB889X", + "01538": "AB889X", + "01540": "AB889X", + "01541": "AB889X", + "01542": "AB889X", + "01543": "AB889X", + "01545": "AB889X", + "01546": "AB889X", + "01550": "AB889X", + "01560": "AB889X", + "01561": "AB889X", + "01562": "AB889X", + "01564": "AB889X", + "01566": "AB889X", + "01568": "AB889X", + "01569": "AB889X", + "01570": "AB889X", + "01571": "AB889X", + "01580": "AB889X", + "01581": "AB889X", + "01582": "AB889X", + "01583": "AB889X", + "01585": "AB889X", + "01586": "AB889X", + "01588": "AB889X", + "01590": "AB889X", + "01601": "AB889X", + "01602": "AB889X", + "01603": "AB889X", + "01604": "AB889X", + "01605": "AB889X", + "01606": "AB889X", + "01607": "AB889X", + "01608": "AB889X", + "01609": "AB889X", + "01610": "AB889X", + "01611": "AB889X", + "01612": "AB889X", + "01613": "AB889X", + "01614": "AB889X", + "01615": "AB889X", + "01653": "AB889X", + "01654": "AB889X", + "01655": "AB889X", + "01701": "AB889X", + "01702": "AB889X", + "01703": "AB889X", + "01704": "AB889X", + "01705": "AB889X", + "01718": "AB889X", + "01719": "AB889X", + "01720": "AB889X", + "01721": "AB889X", + "01730": "AB889X", + "01731": "AB889X", + "01740": "AB889X", + "01741": "AB889X", + "01742": "AB889X", + "01745": "AB889X", + "01746": "AB889X", + "01747": "AB889X", + "01748": "AB889X", + "01749": "AB889X", + "01752": "AB889X", + "01754": "AB889X", + "01756": "AB889X", + "01757": "AB889X", + "01760": "AB889X", + "01770": "AB889X", + "01772": "AB889X", + "01773": "AB889X", + "01775": "AB889X", + "01776": "AB889X", + "01778": "AB889X", + "01784": "AB889X", + "01801": "AB889X", + "01803": "AB889X", + "01805": "AB889X", + "01806": "AB889X", + "01807": "AB889X", + "01808": "AB889X", + "01810": "AB889X", + "01812": "AB889X", + "01813": "AB889X", + "01815": "AB889X", + "01821": "AB889X", + "01822": "AB889X", + "01824": "AB889X", + "01826": "AB889X", + "01827": "AB889X", + "01830": "AB889X", + "01831": "AB889X", + "01832": "AB889X", + "01833": "AB889X", + "01834": "AB889X", + "01835": "AB889X", + "01840": "AB889X", + "01841": "AB889X", + "01842": "AB889X", + "01843": "AB889X", + "01844": "AB889X", + "01845": "AB889X", + "01850": "AB889X", + "01851": "AB889X", + "01852": "AB889X", + "01853": "AB889X", + "01854": "AB889X", + "01860": "AB889X", + "01862": "AB889X", + "01863": "AB889X", + "01864": "AB889X", + "01865": "AB889X", + "01866": "AB889X", + "01867": "AB889X", + "01876": "AB889X", + "01879": "AB889X", + "01880": "AB889X", + "01885": "AB889X", + "01886": "AB889X", + "01887": "AB889X", + "01888": "AB889X", + "01889": "AB889X", + "01890": "AB889X", + "01899": "AB889X", + "01901": "AB889X", + "01902": "AB889X", + "01903": "AB889X", + "01904": "AB889X", + "01905": "AB889X", + "01906": "AB889X", + "01907": "AB889X", + "01908": "AB889X", + "01910": "AB889X", + "01913": "AB889X", + "01915": "AB889X", + "01921": "AB889X", + "01922": "AB889X", + "01923": "AB889X", + "01929": "AB889X", + "01930": "AB889X", + "01931": "AB889X", + "01936": "AB889X", + "01937": "AB889X", + "01938": "AB889X", + "01940": "AB889X", + "01944": "AB889X", + "01945": "AB889X", + "01949": "AB889X", + "01950": "AB889X", + "01951": "AB889X", + "01952": "AB889X", + "01960": "AB889X", + "01961": "AB889X", + "01965": "AB889X", + "01966": "AB889X", + "01969": "AB889X", + "01970": "AB889X", + "01971": "AB889X", + "01982": "AB889X", + "01983": "AB889X", + "01984": "AB889X", + "01985": "AB889X", + "02018": "AB889X", + "02019": "AB889X", + "02020": "AB889X", + "02021": "AB889X", + "02025": "AB889X", + "02026": "AB889X", + "02027": "AB889X", + "02030": "AB889X", + "02031": "AB889X", + "02032": "AB889X", + "02035": "AB889X", + "02038": "AB889X", + "02040": "AB889X", + "02041": "AB889X", + "02043": "AB889X", + "02044": "AB889X", + "02045": "AB889X", + "02047": "AB889X", + "02048": "AB889X", + "02050": "AB889X", + "02051": "AB889X", + "02052": "AB889X", + "02053": "AB889X", + "02054": "AB889X", + "02055": "AB889X", + "02056": "AB889X", + "02059": "AB889X", + "02060": "AB889X", + "02061": "AB889X", + "02062": "AB889X", + "02065": "AB889X", + "02066": "AB889X", + "02067": "AB889X", + "02070": "AB889X", + "02071": "AB889X", + "02072": "AB889X", + "02081": "AB889X", + "02090": "AB889X", + "02093": "AB889X", + "02108": "AB889X", + "02109": "AB889X", + "02110": "AB889X", + "02111": "AB889X", + "02112": "AB889X", + "02113": "AB889X", + "02114": "AB889X", + "02115": "AB889X", + "02116": "AB889X", + "02117": "AB889X", + "02118": "AB889X", + "02119": "AB889X", + "02120": "AB889X", + "02121": "AB889X", + "02122": "AB889X", + "02123": "AB889X", + "02124": "AB889X", + "02125": "AB889X", + "02126": "AB889X", + "02127": "AB889X", + "02128": "AB889X", + "02129": "AB889X", + "02130": "AB889X", + "02131": "AB889X", + "02132": "AB889X", + "02133": "AB889X", + "02134": "AB889X", + "02135": "AB889X", + "02136": "AB889X", + "02137": "AB889X", + "02138": "AB889X", + "02139": "AB889X", + "02140": "AB889X", + "02141": "AB889X", + "02142": "AB889X", + "02143": "AB889X", + "02144": "AB889X", + "02145": "AB889X", + "02148": "AB889X", + "02149": "AB889X", + "02150": "AB889X", + "02151": "AB889X", + "02152": "AB889X", + "02153": "AB889X", + "02155": "AB889X", + "02156": "AB889X", + "02163": "AB889X", + "02169": "AB889X", + "02170": "AB889X", + "02171": "AB889X", + "02176": "AB889X", + "02180": "AB889X", + "02184": "AB889X", + "02185": "AB889X", + "02186": "AB889X", + "02187": "AB889X", + "02188": "AB889X", + "02189": "AB889X", + "02190": "AB889X", + "02191": "AB889X", + "02196": "AB889X", + "02199": "AB889X", + "02201": "AB889X", + "02203": "AB889X", + "02204": "AB889X", + "02205": "AB889X", + "02206": "AB889X", + "02207": "AB889X", + "02210": "AB889X", + "02211": "AB889X", + "02212": "AB889X", + "02215": "AB889X", + "02216": "AB889X", + "02217": "AB889X", + "02222": "AB889X", + "02228": "AB889X", + "02238": "AB889X", + "02239": "AB889X", + "02241": "AB889X", + "02266": "AB889X", + "02269": "AB889X", + "02283": "AB889X", + "02284": "AB889X", + "02293": "AB889X", + "02295": "AB889X", + "02297": "AB889X", + "02298": "AB889X", + "02301": "AB889X", + "02302": "AB889X", + "02303": "AB889X", + "02304": "AB889X", + "02305": "AB889X", + "02322": "AB889X", + "02324": "AB889X", + "02325": "AB889X", + "02327": "AB889X", + "02330": "AB889X", + "02331": "AB889X", + "02332": "AB889X", + "02333": "AB889X", + "02334": "AB889X", + "02337": "AB889X", + "02338": "AB889X", + "02339": "AB889X", + "02340": "AB889X", + "02341": "AB889X", + "02343": "AB889X", + "02344": "AB889X", + "02345": "AB889X", + "02346": "AB889X", + "02347": "AB889X", + "02348": "AB889X", + "02349": "AB889X", + "02350": "AB889X", + "02351": "AB889X", + "02355": "AB889X", + "02356": "AB889X", + "02357": "AB889X", + "02358": "AB889X", + "02359": "AB889X", + "02360": "AB889X", + "02361": "AB889X", + "02362": "AB889X", + "02364": "AB889X", + "02366": "AB889X", + "02367": "AB889X", + "02368": "AB889X", + "02370": "AB889X", + "02375": "AB889X", + "02379": "AB889X", + "02381": "AB889X", + "02382": "AB889X", + "02420": "AB889X", + "02421": "AB889X", + "02445": "AB889X", + "02446": "AB889X", + "02447": "AB889X", + "02451": "AB889X", + "02452": "AB889X", + "02453": "AB889X", + "02454": "AB889X", + "02455": "AB889X", + "02456": "AB889X", + "02457": "AB889X", + "02458": "AB890X", + "02459": "AB889X", + "02460": "AB889X", + "02461": "AB889X", + "02462": "AB889X", + "02464": "AB889X", + "02465": "AB889X", + "02466": "AB889X", + "02467": "AB889X", + "02468": "AB889X", + "02471": "AB889X", + "02472": "AB889X", + "02474": "AB889X", + "02475": "AB889X", + "02476": "AB889X", + "02477": "AB889X", + "02478": "AB889X", + "02479": "AB889X", + "02481": "AB889X", + "02482": "AB889X", + "02492": "AB889X", + "02493": "AB889X", + "02494": "AB889X", + "02495": "AB889X", + "02532": "AB889X", + "02534": "AB889X", + "02535": "AB889X", + "02536": "AB889X", + "02537": "AB889X", + "02538": "AB889X", + "02539": "AB889X", + "02540": "AB889X", + "02541": "AB889X", + "02542": "AB889X", + "02543": "AB889X", + "02552": "AB889X", + "02553": "AB889X", + "02554": "AB889X", + "02556": "AB889X", + "02557": "AB889X", + "02558": "AB889X", + "02559": "AB889X", + "02561": "AB889X", + "02562": "AB889X", + "02563": "AB889X", + "02564": "AB889X", + "02565": "AB889X", + "02568": "AB889X", + "02571": "AB889X", + "02573": "AB889X", + "02574": "AB889X", + "02575": "AB889X", + "02576": "AB889X", + "02584": "AB889X", + "02601": "AB889X", + "02630": "AB889X", + "02631": "AB889X", + "02632": "AB889X", + "02633": "AB889X", + "02634": "AB889X", + "02635": "AB889X", + "02636": "AB889X", + "02637": "AB889X", + "02638": "AB889X", + "02639": "AB889X", + "02641": "AB889X", + "02642": "AB889X", + "02643": "AB889X", + "02644": "AB889X", + "02645": "AB889X", + "02646": "AB889X", + "02647": "AB889X", + "02648": "AB889X", + "02649": "AB889X", + "02650": "AB889X", + "02651": "AB889X", + "02652": "AB889X", + "02653": "AB889X", + "02655": "AB889X", + "02657": "AB889X", + "02659": "AB889X", + "02660": "AB889X", + "02661": "AB889X", + "02662": "AB889X", + "02663": "AB889X", + "02664": "AB889X", + "02666": "AB889X", + "02667": "AB889X", + "02668": "AB889X", + "02669": "AB889X", + "02670": "AB889X", + "02671": "AB889X", + "02672": "AB889X", + "02673": "AB889X", + "02675": "AB889X", + "02702": "AB889X", + "02703": "AB889X", + "02712": "AB889X", + "02713": "AB889X", + "02714": "AB889X", + "02715": "AB889X", + "02717": "AB889X", + "02718": "AB889X", + "02719": "AB889X", + "02720": "AB889X", + "02721": "AB889X", + "02722": "AB889X", + "02723": "AB889X", + "02724": "AB889X", + "02725": "AB889X", + "02726": "AB889X", + "02738": "AB889X", + "02739": "AB889X", + "02740": "AB889X", + "02741": "AB889X", + "02742": "AB889X", + "02743": "AB889X", + "02744": "AB889X", + "02745": "AB889X", + "02746": "AB889X", + "02747": "AB889X", + "02748": "AB889X", + "02760": "AB889X", + "02761": "AB889X", + "02762": "AB889X", + "02763": "AB889X", + "02764": "AB889X", + "02766": "AB889X", + "02767": "AB889X", + "02768": "AB889X", + "02769": "AB889X", + "02770": "AB889X", + "02771": "AB889X", + "02777": "AB889X", + "02779": "AB889X", + "02780": "AB889X", + "02783": "AB889X", + "02790": "AB889X", + "02791": "AB889X", + "02801": "AB889X", + "02802": "AB889X", + "02804": "AB889X", + "02806": "AB889X", + "02807": "AB889X", + "02808": "AB889X", + "02809": "AB889X", + "02812": "AB889X", + "02813": "AB889X", + "02814": "AB889X", + "02815": "AB889X", + "02816": "AB889X", + "02817": "AB889X", + "02818": "AB889X", + "02822": "AB889X", + "02823": "AB889X", + "02824": "AB889X", + "02825": "AB889X", + "02826": "AB889X", + "02827": "AB889X", + "02828": "AB889X", + "02829": "AB889X", + "02830": "AB889X", + "02831": "AB889X", + "02832": "AB889X", + "02833": "AB889X", + "02835": "AB889X", + "02836": "AB889X", + "02837": "AB889X", + "02838": "AB889X", + "02839": "AB889X", + "02840": "AB889X", + "02841": "AB889X", + "02842": "AB889X", + "02852": "AB889X", + "02854": "AB889X", + "02857": "AB889X", + "02858": "AB889X", + "02859": "AB889X", + "02860": "AB889X", + "02861": "AB889X", + "02862": "AB889X", + "02863": "AB889X", + "02864": "AB889X", + "02865": "AB889X", + "02871": "AB889X", + "02872": "AB889X", + "02873": "AB889X", + "02874": "AB889X", + "02875": "AB889X", + "02876": "AB889X", + "02877": "AB889X", + "02878": "AB889X", + "02879": "AB889X", + "02880": "AB889X", + "02881": "AB889X", + "02882": "AB889X", + "02883": "AB889X", + "02885": "AB889X", + "02886": "AB889X", + "02887": "AB889X", + "02888": "AB889X", + "02889": "AB889X", + "02891": "AB889X", + "02892": "AB889X", + "02893": "AB889X", + "02894": "AB889X", + "02895": "AB889X", + "02896": "AB889X", + "02898": "AB889X", + "02901": "AB889X", + "02902": "AB889X", + "02903": "AB889X", + "02904": "AB889X", + "02905": "AB889X", + "02906": "AB889X", + "02907": "AB889X", + "02908": "AB889X", + "02909": "AB889X", + "02910": "AB889X", + "02911": "AB889X", + "02912": "AB889X", + "02914": "AB889X", + "02915": "AB889X", + "02916": "AB889X", + "02917": "AB889X", + "02918": "AB889X", + "02919": "AB889X", + "02920": "AB889X", + "02921": "AB889X", + "02940": "AB889X", + "03031": "AB889X", + "03032": "AB889X", + "03033": "AB889X", + "03034": "AB889X", + "03036": "AB889X", + "03037": "AB889X", + "03038": "AB889X", + "03040": "AB889X", + "03041": "AB889X", + "03042": "AB889X", + "03043": "AB889X", + "03044": "AB889X", + "03045": "AB889X", + "03046": "AB889X", + "03047": "AB889X", + "03048": "AB889X", + "03049": "AB889X", + "03051": "AB889X", + "03052": "AB889X", + "03053": "AB889X", + "03054": "AB889X", + "03055": "AB889X", + "03057": "AB889X", + "03060": "AB889X", + "03061": "AB889X", + "03062": "AB889X", + "03063": "AB889X", + "03064": "AB889X", + "03070": "AB889X", + "03071": "AB889X", + "03073": "AB889X", + "03076": "AB889X", + "03077": "AB889X", + "03079": "AB889X", + "03082": "AB889X", + "03084": "AB889X", + "03086": "AB889X", + "03087": "AB889X", + "03101": "AB889X", + "03102": "AB889X", + "03103": "AB889X", + "03104": "AB889X", + "03105": "AB889X", + "03106": "AB889X", + "03107": "AB889X", + "03108": "AB889X", + "03109": "AB889X", + "03110": "AB889X", + "03111": "AB889X", + "03215": "AB889X", + "03216": "AB889X", + "03217": "AB889X", + "03218": "AB889X", + "03220": "AB889X", + "03221": "AB889X", + "03222": "AB889X", + "03223": "AB889X", + "03224": "AB889X", + "03225": "AB889X", + "03226": "AB889X", + "03227": "AB889X", + "03229": "AB889X", + "03230": "AB889X", + "03231": "AB889X", + "03233": "AB889X", + "03234": "AB889X", + "03235": "AB889X", + "03237": "AB889X", + "03238": "AB889X", + "03240": "AB889X", + "03241": "AB889X", + "03242": "AB889X", + "03243": "AB889X", + "03244": "AB889X", + "03245": "AB889X", + "03246": "AB889X", + "03247": "AB889X", + "03249": "AB889X", + "03251": "AB889X", + "03252": "AB889X", + "03253": "AB889X", + "03254": "AB889X", + "03255": "AB889X", + "03256": "AB889X", + "03257": "AB889X", + "03258": "AB889X", + "03259": "AB889X", + "03260": "AB889X", + "03261": "AB889X", + "03262": "AB889X", + "03263": "AB889X", + "03264": "AB889X", + "03266": "AB889X", + "03268": "AB889X", + "03269": "AB889X", + "03272": "AB889X", + "03273": "AB889X", + "03274": "AB889X", + "03275": "AB889X", + "03276": "AB889X", + "03278": "AB889X", + "03279": "AB889X", + "03280": "AB889X", + "03281": "AB889X", + "03282": "AB889X", + "03284": "AB889X", + "03287": "AB889X", + "03289": "AB889X", + "03290": "AB889X", + "03291": "AB889X", + "03293": "AB889X", + "03298": "AB889X", + "03299": "AB889X", + "03301": "AB889X", + "03302": "AB889X", + "03303": "AB889X", + "03304": "AB889X", + "03305": "AB889X", + "03307": "AB889X", + "03431": "AB889X", + "03435": "AB889X", + "03440": "AB889X", + "03441": "AB889X", + "03442": "AB889X", + "03443": "AB889X", + "03444": "AB889X", + "03445": "AB889X", + "03446": "AB889X", + "03447": "AB889X", + "03448": "AB889X", + "03449": "AB889X", + "03450": "AB889X", + "03451": "AB889X", + "03452": "AB889X", + "03455": "AB889X", + "03456": "AB889X", + "03457": "AB889X", + "03458": "AB889X", + "03461": "AB889X", + "03462": "AB889X", + "03464": "AB889X", + "03465": "AB889X", + "03466": "AB889X", + "03467": "AB889X", + "03468": "AB889X", + "03469": "AB889X", + "03470": "AB889X", + "03561": "AB889X", + "03570": "AB889X", + "03574": "AB889X", + "03575": "AB889X", + "03576": "AB889X", + "03579": "AB889X", + "03580": "AB889X", + "03581": "AB889X", + "03582": "AB889X", + "03583": "AB889X", + "03584": "AB889X", + "03585": "AB889X", + "03586": "AB889X", + "03588": "AB889X", + "03589": "AB889X", + "03590": "AB889X", + "03592": "AB889X", + "03593": "AB889X", + "03595": "AB889X", + "03597": "AB889X", + "03598": "AB889X", + "03601": "AB889X", + "03602": "AB889X", + "03603": "AB889X", + "03604": "AB889X", + "03605": "AB889X", + "03607": "AB889X", + "03608": "AB889X", + "03609": "AB889X", + "03740": "AB889X", + "03741": "AB889X", + "03743": "AB889X", + "03745": "AB889X", + "03746": "AB889X", + "03748": "AB889X", + "03749": "AB889X", + "03750": "AB889X", + "03751": "AB889X", + "03752": "AB889X", + "03753": "AB889X", + "03754": "AB889X", + "03755": "AB889X", + "03756": "AB889X", + "03765": "AB889X", + "03766": "AB889X", + "03768": "AB889X", + "03769": "AB889X", + "03770": "AB889X", + "03771": "AB889X", + "03773": "AB889X", + "03774": "AB889X", + "03777": "AB889X", + "03779": "AB889X", + "03780": "AB889X", + "03781": "AB889X", + "03782": "AB889X", + "03784": "AB889X", + "03785": "AB889X", + "03801": "AB889X", + "03802": "AB889X", + "03803": "AB889X", + "03804": "AB889X", + "03805": "AB889X", + "03809": "AB889X", + "03810": "AB889X", + "03811": "AB889X", + "03812": "AB889X", + "03813": "AB889X", + "03814": "AB889X", + "03815": "AB889X", + "03816": "AB889X", + "03817": "AB889X", + "03818": "AB889X", + "03819": "AB889X", + "03820": "AB889X", + "03821": "AB889X", + "03822": "AB889X", + "03823": "AB889X", + "03824": "AB889X", + "03825": "AB889X", + "03826": "AB889X", + "03827": "AB889X", + "03830": "AB889X", + "03832": "AB889X", + "03833": "AB889X", + "03835": "AB889X", + "03836": "AB889X", + "03837": "AB889X", + "03838": "AB889X", + "03839": "AB889X", + "03840": "AB889X", + "03841": "AB889X", + "03842": "AB889X", + "03843": "AB889X", + "03844": "AB889X", + "03845": "AB889X", + "03846": "AB889X", + "03847": "AB889X", + "03848": "AB889X", + "03849": "AB889X", + "03850": "AB889X", + "03851": "AB889X", + "03852": "AB889X", + "03853": "AB889X", + "03854": "AB889X", + "03855": "AB889X", + "03856": "AB889X", + "03857": "AB889X", + "03858": "AB889X", + "03859": "AB889X", + "03860": "AB889X", + "03861": "AB889X", + "03862": "AB889X", + "03864": "AB889X", + "03865": "AB889X", + "03866": "AB889X", + "03867": "AB889X", + "03868": "AB889X", + "03869": "AB889X", + "03870": "AB889X", + "03871": "AB889X", + "03872": "AB889X", + "03873": "AB889X", + "03874": "AB889X", + "03875": "AB889X", + "03878": "AB889X", + "03882": "AB889X", + "03883": "AB889X", + "03884": "AB889X", + "03885": "AB889X", + "03886": "AB889X", + "03887": "AB889X", + "03890": "AB889X", + "03894": "AB889X", + "03896": "AB889X", + "03897": "AB889X", + "03901": "AB889X", + "03902": "AB889X", + "03903": "AB889X", + "03904": "AB889X", + "03905": "AB889X", + "03906": "AB889X", + "03907": "AB889X", + "03908": "AB889X", + "03909": "AB889X", + "03910": "AB889X", + "03911": "AB889X", + "04001": "AB889X", + "04002": "AB889X", + "04003": "AB889X", + "04004": "AB889X", + "04005": "AB889X", + "04006": "AB889X", + "04007": "AB889X", + "04008": "AB889X", + "04009": "AB889X", + "04010": "AB889X", + "04011": "AB889X", + "04013": "AB889X", + "04014": "AB889X", + "04015": "AB889X", + "04016": "AB889X", + "04017": "AB889X", + "04019": "AB889X", + "04020": "AB889X", + "04021": "AB889X", + "04022": "AB889X", + "04024": "AB889X", + "04027": "AB889X", + "04028": "AB889X", + "04029": "AB889X", + "04030": "AB889X", + "04032": "AB889X", + "04033": "AB889X", + "04034": "AB889X", + "04037": "AB889X", + "04038": "AB889X", + "04039": "AB889X", + "04040": "AB889X", + "04041": "AB889X", + "04042": "AB889X", + "04043": "AB889X", + "04046": "AB889X", + "04047": "AB889X", + "04048": "AB889X", + "04049": "AB889X", + "04050": "AB889X", + "04051": "AB889X", + "04054": "AB889X", + "04055": "AB889X", + "04056": "AB889X", + "04057": "AB889X", + "04061": "AB889X", + "04062": "AB889X", + "04063": "AB889X", + "04064": "AB889X", + "04066": "AB889X", + "04068": "AB889X", + "04069": "AB889X", + "04070": "AB889X", + "04071": "AB889X", + "04072": "AB889X", + "04073": "AB889X", + "04074": "AB889X", + "04075": "AB889X", + "04076": "AB889X", + "04077": "AB889X", + "04078": "AB889X", + "04079": "AB889X", + "04082": "AB889X", + "04083": "AB889X", + "04084": "AB889X", + "04085": "AB889X", + "04086": "AB889X", + "04087": "AB889X", + "04088": "AB889X", + "04090": "AB889X", + "04091": "AB889X", + "04092": "AB889X", + "04093": "AB889X", + "04094": "AB889X", + "04095": "AB889X", + "04096": "AB889X", + "04097": "AB889X", + "04098": "AB889X", + "04101": "AB889X", + "04102": "AB889X", + "04103": "AB889X", + "04104": "AB889X", + "04105": "AB889X", + "04106": "AB889X", + "04107": "AB889X", + "04108": "AB889X", + "04109": "AB889X", + "04110": "AB889X", + "04112": "AB889X", + "04116": "AB889X", + "04122": "AB889X", + "04123": "AB889X", + "04124": "AB889X", + "04210": "AB889X", + "04211": "AB889X", + "04212": "AB889X", + "04216": "AB889X", + "04217": "AB889X", + "04219": "AB889X", + "04220": "AB889X", + "04221": "AB889X", + "04222": "AB889X", + "04223": "AB889X", + "04224": "AB889X", + "04225": "AB889X", + "04226": "AB889X", + "04227": "AB889X", + "04228": "AB889X", + "04230": "AB889X", + "04231": "AB889X", + "04234": "AB889X", + "04236": "AB889X", + "04237": "AB889X", + "04238": "AB889X", + "04239": "AB889X", + "04240": "AB889X", + "04241": "AB889X", + "04243": "AB889X", + "04250": "AB889X", + "04252": "AB889X", + "04253": "AB889X", + "04254": "AB889X", + "04255": "AB889X", + "04256": "AB889X", + "04257": "AB889X", + "04258": "AB889X", + "04259": "AB889X", + "04260": "AB889X", + "04261": "AB889X", + "04262": "AB889X", + "04263": "AB889X", + "04265": "AB889X", + "04266": "AB889X", + "04267": "AB889X", + "04268": "AB889X", + "04270": "AB889X", + "04271": "AB889X", + "04274": "AB889X", + "04275": "AB889X", + "04276": "AB889X", + "04278": "AB889X", + "04280": "AB889X", + "04281": "AB889X", + "04282": "AB889X", + "04284": "AB889X", + "04285": "AB889X", + "04286": "AB889X", + "04287": "AB889X", + "04288": "AB889X", + "04289": "AB889X", + "04290": "AB889X", + "04291": "AB889X", + "04292": "AB889X", + "04294": "AB889X", + "04330": "AB889X", + "04332": "AB889X", + "04333": "AB889X", + "04336": "AB889X", + "04338": "AB889X", + "04341": "AB889X", + "04342": "AB889X", + "04343": "AB889X", + "04344": "AB889X", + "04345": "AB889X", + "04346": "AB889X", + "04347": "AB889X", + "04348": "AB889X", + "04349": "AB889X", + "04350": "AB889X", + "04351": "AB889X", + "04352": "AB889X", + "04353": "AB889X", + "04354": "AB889X", + "04355": "AB889X", + "04357": "AB889X", + "04358": "AB889X", + "04359": "AB889X", + "04360": "AB889X", + "04363": "AB889X", + "04364": "AB889X", + "04401": "AB889X", + "04402": "AB889X", + "04406": "AB889X", + "04408": "AB889X", + "04410": "AB889X", + "04411": "AB889X", + "04412": "AB889X", + "04413": "AB889X", + "04414": "AB889X", + "04415": "AB889X", + "04416": "AB889X", + "04417": "AB889X", + "04418": "AB889X", + "04419": "AB889X", + "04420": "AB889X", + "04421": "AB889X", + "04422": "AB889X", + "04424": "AB889X", + "04426": "AB889X", + "04427": "AB889X", + "04428": "AB889X", + "04429": "AB889X", + "04430": "AB889X", + "04431": "AB889X", + "04434": "AB889X", + "04435": "AB889X", + "04438": "AB889X", + "04441": "AB889X", + "04442": "AB889X", + "04443": "AB889X", + "04444": "AB889X", + "04448": "AB889X", + "04449": "AB889X", + "04450": "AB889X", + "04451": "AB889X", + "04453": "AB889X", + "04454": "AB889X", + "04455": "AB889X", + "04456": "AB889X", + "04457": "AB889X", + "04459": "AB889X", + "04460": "AB889X", + "04461": "AB889X", + "04462": "AB889X", + "04463": "AB889X", + "04464": "AB889X", + "04467": "AB889X", + "04468": "AB889X", + "04469": "AB889X", + "04471": "AB889X", + "04472": "AB889X", + "04473": "AB889X", + "04474": "AB889X", + "04475": "AB889X", + "04476": "AB889X", + "04478": "AB889X", + "04479": "AB889X", + "04481": "AB889X", + "04485": "AB889X", + "04487": "AB889X", + "04488": "AB889X", + "04489": "AB889X", + "04490": "AB889X", + "04491": "AB889X", + "04492": "AB889X", + "04493": "AB889X", + "04495": "AB889X", + "04496": "AB889X", + "04497": "AB889X", + "04530": "AB889X", + "04535": "AB889X", + "04537": "AB889X", + "04538": "AB889X", + "04539": "AB889X", + "04541": "AB889X", + "04543": "AB889X", + "04544": "AB889X", + "04547": "AB889X", + "04548": "AB889X", + "04549": "AB889X", + "04551": "AB889X", + "04553": "AB889X", + "04554": "AB889X", + "04555": "AB889X", + "04556": "AB889X", + "04558": "AB889X", + "04562": "AB889X", + "04563": "AB889X", + "04564": "AB889X", + "04565": "AB889X", + "04568": "AB889X", + "04570": "AB889X", + "04571": "AB889X", + "04572": "AB889X", + "04573": "AB889X", + "04574": "AB889X", + "04575": "AB889X", + "04576": "AB889X", + "04578": "AB889X", + "04579": "AB889X", + "04605": "AB889X", + "04606": "AB889X", + "04607": "AB889X", + "04609": "AB889X", + "04611": "AB889X", + "04612": "AB889X", + "04613": "AB889X", + "04614": "AB889X", + "04616": "AB889X", + "04617": "AB889X", + "04619": "AB889X", + "04622": "AB889X", + "04623": "AB889X", + "04624": "AB889X", + "04625": "AB889X", + "04626": "AB889X", + "04627": "AB889X", + "04628": "AB889X", + "04629": "AB889X", + "04630": "AB889X", + "04631": "AB889X", + "04634": "AB889X", + "04635": "AB889X", + "04637": "AB889X", + "04640": "AB889X", + "04642": "AB889X", + "04643": "AB889X", + "04644": "AB889X", + "04645": "AB889X", + "04646": "AB889X", + "04648": "AB889X", + "04649": "AB889X", + "04650": "AB889X", + "04652": "AB889X", + "04653": "AB889X", + "04654": "AB889X", + "04655": "AB889X", + "04657": "AB889X", + "04658": "AB889X", + "04660": "AB889X", + "04662": "AB889X", + "04664": "AB889X", + "04666": "AB889X", + "04667": "AB889X", + "04668": "AB889X", + "04669": "AB889X", + "04671": "AB889X", + "04672": "AB889X", + "04673": "AB889X", + "04674": "AB889X", + "04675": "AB889X", + "04676": "AB889X", + "04677": "AB889X", + "04679": "AB889X", + "04680": "AB889X", + "04681": "AB889X", + "04683": "AB889X", + "04684": "AB889X", + "04685": "AB889X", + "04686": "AB889X", + "04691": "AB889X", + "04693": "AB889X", + "04694": "AB889X", + "04730": "AB889X", + "04732": "AB889X", + "04733": "AB889X", + "04734": "AB889X", + "04735": "AB889X", + "04736": "AB889X", + "04737": "AB889X", + "04738": "AB889X", + "04739": "AB889X", + "04740": "AB889X", + "04741": "AB889X", + "04742": "AB889X", + "04743": "AB889X", + "04744": "AB889X", + "04745": "AB889X", + "04746": "AB889X", + "04747": "AB889X", + "04750": "AB889X", + "04751": "AB889X", + "04756": "AB889X", + "04757": "AB889X", + "04758": "AB889X", + "04760": "AB889X", + "04761": "AB889X", + "04762": "AB889X", + "04763": "AB889X", + "04764": "AB889X", + "04765": "AB889X", + "04766": "AB889X", + "04768": "AB889X", + "04769": "AB889X", + "04772": "AB889X", + "04773": "AB889X", + "04774": "AB889X", + "04775": "AB889X", + "04776": "AB889X", + "04777": "AB889X", + "04779": "AB889X", + "04780": "AB889X", + "04781": "AB889X", + "04783": "AB889X", + "04785": "AB889X", + "04786": "AB889X", + "04787": "AB889X", + "04841": "AB889X", + "04843": "AB889X", + "04846": "AB889X", + "04847": "AB889X", + "04848": "AB889X", + "04849": "AB889X", + "04850": "AB889X", + "04851": "AB889X", + "04852": "AB889X", + "04853": "AB889X", + "04854": "AB889X", + "04855": "AB889X", + "04856": "AB889X", + "04858": "AB889X", + "04859": "AB889X", + "04860": "AB889X", + "04861": "AB889X", + "04862": "AB889X", + "04863": "AB889X", + "04864": "AB889X", + "04865": "AB889X", + "04901": "AB889X", + "04903": "AB889X", + "04910": "AB889X", + "04911": "AB889X", + "04912": "AB889X", + "04915": "AB889X", + "04917": "AB889X", + "04918": "AB889X", + "04920": "AB889X", + "04921": "AB889X", + "04922": "AB889X", + "04923": "AB889X", + "04924": "AB889X", + "04925": "AB889X", + "04926": "AB889X", + "04927": "AB889X", + "04928": "AB889X", + "04929": "AB889X", + "04930": "AB889X", + "04932": "AB889X", + "04933": "AB889X", + "04935": "AB889X", + "04936": "AB889X", + "04937": "AB889X", + "04938": "AB889X", + "04939": "AB889X", + "04940": "AB889X", + "04941": "AB889X", + "04942": "AB889X", + "04943": "AB889X", + "04944": "AB889X", + "04945": "AB889X", + "04947": "AB889X", + "04949": "AB889X", + "04950": "AB889X", + "04951": "AB889X", + "04952": "AB889X", + "04953": "AB889X", + "04954": "AB889X", + "04955": "AB889X", + "04956": "AB889X", + "04957": "AB889X", + "04958": "AB889X", + "04961": "AB889X", + "04962": "AB889X", + "04963": "AB889X", + "04964": "AB889X", + "04965": "AB889X", + "04966": "AB889X", + "04967": "AB889X", + "04969": "AB889X", + "04970": "AB889X", + "04971": "AB889X", + "04972": "AB889X", + "04973": "AB889X", + "04974": "AB889X", + "04975": "AB889X", + "04976": "AB889X", + "04978": "AB889X", + "04979": "AB889X", + "04981": "AB889X", + "04982": "AB889X", + "04983": "AB889X", + "04984": "AB889X", + "04985": "AB889X", + "04986": "AB889X", + "04987": "AB889X", + "04988": "AB889X", + "04989": "AB889X", + "04992": "AB889X", + "05001": "AB889X", + "05009": "AB889X", + "05030": "AB889X", + "05031": "AB889X", + "05032": "AB889X", + "05033": "AB889X", + "05034": "AB889X", + "05035": "AB889X", + "05036": "AB889X", + "05037": "AB889X", + "05038": "AB889X", + "05039": "AB889X", + "05040": "AB889X", + "05041": "AB889X", + "05042": "AB889X", + "05043": "AB889X", + "05045": "AB889X", + "05046": "AB889X", + "05047": "AB889X", + "05048": "AB889X", + "05049": "AB889X", + "05050": "AB889X", + "05051": "AB889X", + "05052": "AB889X", + "05053": "AB889X", + "05054": "AB889X", + "05055": "AB889X", + "05056": "AB889X", + "05058": "AB889X", + "05059": "AB889X", + "05060": "AB889X", + "05061": "AB889X", + "05062": "AB889X", + "05065": "AB889X", + "05067": "AB889X", + "05068": "AB889X", + "05069": "AB889X", + "05070": "AB889X", + "05071": "AB889X", + "05072": "AB889X", + "05073": "AB889X", + "05074": "AB889X", + "05075": "AB889X", + "05076": "AB889X", + "05077": "AB889X", + "05079": "AB889X", + "05081": "AB889X", + "05083": "AB889X", + "05084": "AB889X", + "05085": "AB889X", + "05086": "AB889X", + "05088": "AB889X", + "05089": "AB889X", + "05091": "AB889X", + "05101": "AB889X", + "05141": "AB889X", + "05142": "AB889X", + "05143": "AB889X", + "05144": "AB889X", + "05146": "AB889X", + "05148": "AB889X", + "05149": "AB889X", + "05150": "AB889X", + "05151": "AB889X", + "05152": "AB889X", + "05153": "AB889X", + "05154": "AB889X", + "05155": "AB889X", + "05156": "AB889X", + "05158": "AB889X", + "05159": "AB889X", + "05161": "AB889X", + "05201": "AB889X", + "05250": "AB889X", + "05251": "AB889X", + "05252": "AB889X", + "05253": "AB889X", + "05254": "AB889X", + "05255": "AB889X", + "05257": "AB889X", + "05260": "AB889X", + "05261": "AB889X", + "05262": "AB889X", + "05301": "AB889X", + "05302": "AB889X", + "05303": "AB889X", + "05304": "AB889X", + "05340": "AB889X", + "05341": "AB889X", + "05342": "AB889X", + "05343": "AB889X", + "05344": "AB889X", + "05345": "AB889X", + "05346": "AB889X", + "05350": "AB889X", + "05351": "AB889X", + "05352": "AB889X", + "05353": "AB889X", + "05354": "AB889X", + "05355": "AB889X", + "05356": "AB889X", + "05357": "AB889X", + "05358": "AB889X", + "05359": "AB889X", + "05360": "AB889X", + "05361": "AB889X", + "05362": "AB889X", + "05363": "AB889X", + "05401": "AB889X", + "05402": "AB889X", + "05403": "AB889X", + "05404": "AB889X", + "05405": "AB889X", + "05406": "AB889X", + "05407": "AB889X", + "05408": "AB889X", + "05439": "AB889X", + "05440": "AB889X", + "05441": "AB889X", + "05442": "AB889X", + "05443": "AB889X", + "05444": "AB889X", + "05445": "AB889X", + "05446": "AB889X", + "05447": "AB889X", + "05448": "AB889X", + "05449": "AB889X", + "05450": "AB889X", + "05451": "AB889X", + "05452": "AB889X", + "05453": "AB889X", + "05454": "AB889X", + "05455": "AB889X", + "05456": "AB889X", + "05457": "AB889X", + "05458": "AB889X", + "05459": "AB889X", + "05460": "AB889X", + "05461": "AB889X", + "05462": "AB889X", + "05463": "AB889X", + "05464": "AB889X", + "05465": "AB889X", + "05466": "AB889X", + "05468": "AB889X", + "05469": "AB889X", + "05470": "AB889X", + "05471": "AB889X", + "05472": "AB889X", + "05473": "AB889X", + "05474": "AB889X", + "05476": "AB889X", + "05477": "AB889X", + "05478": "AB889X", + "05479": "AB889X", + "05481": "AB889X", + "05482": "AB889X", + "05483": "AB889X", + "05485": "AB889X", + "05486": "AB889X", + "05487": "AB889X", + "05488": "AB889X", + "05489": "AB889X", + "05490": "AB889X", + "05491": "AB889X", + "05492": "AB889X", + "05494": "AB889X", + "05495": "AB889X", + "05501": "AB889X", + "05544": "AB889X", + "05601": "AB889X", + "05602": "AB889X", + "05603": "AB889X", + "05604": "AB889X", + "05609": "AB889X", + "05620": "AB889X", + "05633": "AB889X", + "05640": "AB889X", + "05641": "AB889X", + "05647": "AB889X", + "05648": "AB889X", + "05649": "AB889X", + "05650": "AB889X", + "05651": "AB889X", + "05652": "AB889X", + "05653": "AB889X", + "05654": "AB889X", + "05655": "AB889X", + "05656": "AB889X", + "05657": "AB889X", + "05658": "AB889X", + "05660": "AB889X", + "05661": "AB889X", + "05662": "AB889X", + "05663": "AB889X", + "05664": "AB889X", + "05665": "AB889X", + "05666": "AB889X", + "05667": "AB889X", + "05669": "AB889X", + "05670": "AB889X", + "05671": "AB889X", + "05672": "AB889X", + "05673": "AB889X", + "05674": "AB889X", + "05675": "AB889X", + "05676": "AB889X", + "05677": "AB889X", + "05678": "AB889X", + "05679": "AB889X", + "05680": "AB889X", + "05681": "AB889X", + "05682": "AB889X", + "05701": "AB889X", + "05702": "AB889X", + "05730": "AB889X", + "05731": "AB889X", + "05732": "AB889X", + "05733": "AB889X", + "05734": "AB889X", + "05735": "AB889X", + "05736": "AB889X", + "05737": "AB889X", + "05738": "AB889X", + "05739": "AB889X", + "05740": "AB889X", + "05741": "AB889X", + "05742": "AB889X", + "05743": "AB889X", + "05744": "AB889X", + "05745": "AB889X", + "05746": "AB889X", + "05747": "AB889X", + "05748": "AB889X", + "05750": "AB889X", + "05751": "AB889X", + "05753": "AB889X", + "05757": "AB889X", + "05758": "AB889X", + "05759": "AB889X", + "05760": "AB889X", + "05761": "AB889X", + "05762": "AB889X", + "05763": "AB889X", + "05764": "AB889X", + "05765": "AB889X", + "05766": "AB889X", + "05767": "AB889X", + "05768": "AB889X", + "05769": "AB889X", + "05770": "AB889X", + "05772": "AB889X", + "05773": "AB889X", + "05774": "AB889X", + "05775": "AB889X", + "05776": "AB889X", + "05777": "AB889X", + "05778": "AB889X", + "05819": "AB889X", + "05820": "AB889X", + "05821": "AB889X", + "05822": "AB889X", + "05823": "AB889X", + "05824": "AB889X", + "05825": "AB889X", + "05826": "AB889X", + "05827": "AB889X", + "05828": "AB889X", + "05829": "AB889X", + "05830": "AB889X", + "05832": "AB889X", + "05833": "AB889X", + "05836": "AB889X", + "05837": "AB889X", + "05838": "AB889X", + "05839": "AB889X", + "05840": "AB889X", + "05841": "AB889X", + "05842": "AB889X", + "05843": "AB889X", + "05845": "AB889X", + "05846": "AB889X", + "05847": "AB889X", + "05848": "AB889X", + "05849": "AB889X", + "05850": "AB889X", + "05851": "AB889X", + "05853": "AB889X", + "05855": "AB889X", + "05857": "AB889X", + "05858": "AB889X", + "05859": "AB889X", + "05860": "AB889X", + "05861": "AB889X", + "05862": "AB889X", + "05863": "AB889X", + "05866": "AB889X", + "05867": "AB889X", + "05868": "AB889X", + "05871": "AB889X", + "05872": "AB889X", + "05873": "AB889X", + "05874": "AB889X", + "05875": "AB889X", + "05901": "AB889X", + "05902": "AB889X", + "05903": "AB889X", + "05904": "AB889X", + "05905": "AB889X", + "05906": "AB889X", + "05907": "AB889X", + "06001": "AB890X", + "06002": "AB890X", + "06006": "AB890X", + "06010": "AB890X", + "06011": "AB890X", + "06013": "AB890X", + "06016": "AB890X", + "06018": "AB890X", + "06019": "AB890X", + "06020": "AB890X", + "06021": "AB890X", + "06022": "AB890X", + "06023": "AB890X", + "06024": "AB890X", + "06025": "AB890X", + "06026": "AB890X", + "06027": "AB890X", + "06028": "AB890X", + "06029": "AB890X", + "06030": "AB890X", + "06031": "AB890X", + "06032": "AB890X", + "06033": "AB890X", + "06034": "AB890X", + "06035": "AB890X", + "06037": "AB890X", + "06039": "AB890X", + "06040": "AB890X", + "06041": "AB890X", + "06042": "AB890X", + "06043": "AB890X", + "06045": "AB890X", + "06050": "AB890X", + "06051": "AB890X", + "06052": "AB890X", + "06053": "AB890X", + "06057": "AB890X", + "06058": "AB890X", + "06059": "AB890X", + "06060": "AB890X", + "06061": "AB890X", + "06062": "AB890X", + "06063": "AB890X", + "06064": "AB890X", + "06065": "AB890X", + "06066": "AB890X", + "06067": "AB890X", + "06068": "AB890X", + "06069": "AB890X", + "06070": "AB890X", + "06071": "AB890X", + "06072": "AB890X", + "06073": "AB890X", + "06074": "AB890X", + "06075": "AB890X", + "06076": "AB890X", + "06077": "AB890X", + "06078": "AB890X", + "06079": "AB890X", + "06080": "AB890X", + "06081": "AB890X", + "06082": "AB890X", + "06083": "AB890X", + "06084": "AB890X", + "06085": "AB890X", + "06087": "AB890X", + "06088": "AB890X", + "06089": "AB890X", + "06090": "AB890X", + "06091": "AB890X", + "06092": "AB890X", + "06093": "AB890X", + "06094": "AB890X", + "06095": "AB890X", + "06096": "AB890X", + "06098": "AB890X", + "06101": "AB890X", + "06102": "AB890X", + "06103": "AB890X", + "06104": "AB890X", + "06105": "AB890X", + "06106": "AB890X", + "06107": "AB890X", + "06108": "AB890X", + "06109": "AB890X", + "06110": "AB890X", + "06111": "AB890X", + "06112": "AB890X", + "06114": "AB890X", + "06115": "AB890X", + "06117": "AB890X", + "06118": "AB890X", + "06119": "AB890X", + "06120": "AB890X", + "06123": "AB890X", + "06126": "AB890X", + "06127": "AB890X", + "06128": "AB890X", + "06129": "AB890X", + "06131": "AB890X", + "06132": "AB890X", + "06133": "AB890X", + "06134": "AB890X", + "06137": "AB890X", + "06138": "AB890X", + "06140": "AB890X", + "06141": "AB890X", + "06142": "AB890X", + "06143": "AB890X", + "06144": "AB890X", + "06145": "AB890X", + "06146": "AB890X", + "06147": "AB890X", + "06150": "AB890X", + "06151": "AB890X", + "06152": "AB890X", + "06153": "AB890X", + "06154": "AB890X", + "06155": "AB890X", + "06156": "AB890X", + "06160": "AB890X", + "06161": "AB890X", + "06167": "AB890X", + "06176": "AB890X", + "06180": "AB890X", + "06183": "AB890X", + "06199": "AB890X", + "06226": "AB890X", + "06230": "AB890X", + "06231": "AB890X", + "06232": "AB890X", + "06233": "AB890X", + "06234": "AB890X", + "06235": "AB890X", + "06237": "AB890X", + "06238": "AB890X", + "06239": "AB890X", + "06241": "AB890X", + "06242": "AB890X", + "06243": "AB890X", + "06244": "AB890X", + "06245": "AB890X", + "06246": "AB890X", + "06247": "AB890X", + "06248": "AB890X", + "06249": "AB890X", + "06250": "AB890X", + "06251": "AB890X", + "06254": "AB890X", + "06255": "AB890X", + "06256": "AB890X", + "06258": "AB890X", + "06259": "AB890X", + "06260": "AB890X", + "06262": "AB890X", + "06263": "AB890X", + "06264": "AB890X", + "06265": "AB890X", + "06266": "AB890X", + "06267": "AB890X", + "06268": "AB890X", + "06269": "AB890X", + "06277": "AB890X", + "06278": "AB890X", + "06279": "AB890X", + "06280": "AB890X", + "06281": "AB890X", + "06282": "AB890X", + "06320": "AB890X", + "06330": "AB890X", + "06331": "AB890X", + "06332": "AB890X", + "06333": "AB890X", + "06334": "AB890X", + "06335": "AB890X", + "06336": "AB890X", + "06338": "AB890X", + "06339": "AB890X", + "06340": "AB890X", + "06349": "AB890X", + "06350": "AB890X", + "06351": "AB890X", + "06353": "AB890X", + "06354": "AB890X", + "06355": "AB890X", + "06357": "AB890X", + "06359": "AB890X", + "06360": "AB890X", + "06365": "AB890X", + "06370": "AB890X", + "06371": "AB890X", + "06372": "AB890X", + "06373": "AB890X", + "06374": "AB890X", + "06375": "AB890X", + "06376": "AB890X", + "06377": "AB890X", + "06378": "AB890X", + "06379": "AB890X", + "06380": "AB890X", + "06382": "AB890X", + "06383": "AB890X", + "06384": "AB890X", + "06385": "AB890X", + "06386": "AB890X", + "06387": "AB890X", + "06388": "AB890X", + "06389": "AB890X", + "06390": "AB890X", + "06401": "AB890X", + "06403": "AB890X", + "06404": "AB890X", + "06405": "AB890X", + "06408": "AB890X", + "06409": "AB890X", + "06410": "AB890X", + "06411": "AB890X", + "06412": "AB890X", + "06413": "AB890X", + "06414": "AB890X", + "06415": "AB890X", + "06416": "AB890X", + "06417": "AB890X", + "06418": "AB890X", + "06419": "AB890X", + "06420": "AB890X", + "06422": "AB890X", + "06423": "AB890X", + "06424": "AB890X", + "06426": "AB890X", + "06437": "AB890X", + "06438": "AB890X", + "06439": "AB890X", + "06440": "AB890X", + "06441": "AB890X", + "06442": "AB890X", + "06443": "AB890X", + "06444": "AB890X", + "06447": "AB890X", + "06450": "AB890X", + "06451": "AB890X", + "06454": "AB890X", + "06455": "AB890X", + "06456": "AB890X", + "06457": "AB890X", + "06459": "AB890X", + "06460": "AB890X", + "06461": "AB890X", + "06467": "AB890X", + "06468": "AB890X", + "06469": "AB890X", + "06470": "AB890X", + "06471": "AB890X", + "06472": "AB890X", + "06473": "AB890X", + "06474": "AB890X", + "06475": "AB890X", + "06477": "AB890X", + "06478": "AB890X", + "06479": "AB890X", + "06480": "AB890X", + "06481": "AB890X", + "06482": "AB890X", + "06483": "AB890X", + "06484": "AB890X", + "06487": "AB890X", + "06488": "AB890X", + "06489": "AB890X", + "06491": "AB890X", + "06492": "AB890X", + "06493": "AB890X", + "06494": "AB890X", + "06495": "AB890X", + "06497": "AB890X", + "06498": "AB890X", + "06501": "AB890X", + "06502": "AB890X", + "06503": "AB890X", + "06504": "AB890X", + "06505": "AB890X", + "06506": "AB890X", + "06507": "AB890X", + "06508": "AB890X", + "06509": "AB890X", + "06510": "AB890X", + "06511": "AB890X", + "06512": "AB890X", + "06513": "AB890X", + "06514": "AB890X", + "06515": "AB890X", + "06516": "AB890X", + "06517": "AB890X", + "06518": "AB890X", + "06519": "AB890X", + "06520": "AB890X", + "06521": "AB890X", + "06524": "AB890X", + "06525": "AB890X", + "06530": "AB890X", + "06531": "AB890X", + "06532": "AB890X", + "06533": "AB890X", + "06534": "AB890X", + "06535": "AB890X", + "06536": "AB890X", + "06537": "AB890X", + "06538": "AB890X", + "06540": "AB890X", + "06601": "AB890X", + "06602": "AB890X", + "06604": "AB890X", + "06605": "AB890X", + "06606": "AB890X", + "06607": "AB890X", + "06608": "AB890X", + "06610": "AB890X", + "06611": "AB890X", + "06612": "AB890X", + "06614": "AB890X", + "06615": "AB890X", + "06650": "AB890X", + "06673": "AB890X", + "06699": "AB890X", + "06701": "AB890X", + "06702": "AB890X", + "06703": "AB890X", + "06704": "AB890X", + "06705": "AB890X", + "06706": "AB890X", + "06708": "AB890X", + "06710": "AB890X", + "06712": "AB890X", + "06716": "AB890X", + "06720": "AB890X", + "06721": "AB890X", + "06722": "AB890X", + "06723": "AB890X", + "06724": "AB890X", + "06725": "AB890X", + "06726": "AB890X", + "06749": "AB890X", + "06750": "AB890X", + "06751": "AB890X", + "06752": "AB890X", + "06753": "AB890X", + "06754": "AB890X", + "06755": "AB890X", + "06756": "AB890X", + "06757": "AB890X", + "06758": "AB890X", + "06759": "AB890X", + "06762": "AB890X", + "06763": "AB890X", + "06770": "AB890X", + "06776": "AB890X", + "06777": "AB890X", + "06778": "AB890X", + "06779": "AB890X", + "06781": "AB890X", + "06782": "AB890X", + "06783": "AB890X", + "06784": "AB890X", + "06785": "AB890X", + "06786": "AB890X", + "06787": "AB890X", + "06790": "AB890X", + "06791": "AB890X", + "06792": "AB890X", + "06793": "AB890X", + "06794": "AB890X", + "06795": "AB890X", + "06796": "AB890X", + "06798": "AB890X", + "06801": "AB890X", + "06804": "AB890X", + "06807": "AB890X", + "06810": "AB890X", + "06811": "AB890X", + "06812": "AB890X", + "06813": "AB890X", + "06814": "AB890X", + "06816": "AB890X", + "06817": "AB890X", + "06820": "AB890X", + "06824": "AB890X", + "06825": "AB890X", + "06828": "AB890X", + "06829": "AB890X", + "06830": "AB890X", + "06831": "AB890X", + "06832": "AB890X", + "06836": "AB890X", + "06838": "AB890X", + "06840": "AB890X", + "06842": "AB890X", + "06850": "AB890X", + "06851": "AB890X", + "06852": "AB890X", + "06853": "AB890X", + "06854": "AB890X", + "06855": "AB890X", + "06856": "AB890X", + "06857": "AB890X", + "06858": "AB890X", + "06859": "AB890X", + "06860": "AB890X", + "06870": "AB890X", + "06875": "AB890X", + "06876": "AB890X", + "06877": "AB890X", + "06878": "AB890X", + "06879": "AB890X", + "06880": "AB890X", + "06881": "AB890X", + "06883": "AB890X", + "06888": "AB890X", + "06889": "AB890X", + "06890": "AB890X", + "06896": "AB890X", + "06897": "AB890X", + "06901": "AB890X", + "06902": "AB890X", + "06903": "AB890X", + "06904": "AB890X", + "06905": "AB890X", + "06906": "AB890X", + "06907": "AB890X", + "06910": "AB890X", + "06911": "AB890X", + "06912": "AB890X", + "06913": "AB890X", + "06914": "AB890X", + "06920": "AB890X", + "06921": "AB890X", + "06922": "AB890X", + "06925": "AB890X", + "06926": "AB890X", + "06927": "AB890X", + "06928": "AB890X", + "07001": "AB890X", + "07002": "AB890X", + "07003": "AB890X", + "07004": "AB890X", + "07005": "AB890X", + "07006": "AB890X", + "07007": "AB890X", + "07008": "AB890X", + "07009": "AB890X", + "07010": "AB890X", + "07011": "AB890X", + "07012": "AB890X", + "07013": "AB890X", + "07014": "AB890X", + "07015": "AB890X", + "07016": "AB890X", + "07017": "AB890X", + "07018": "AB890X", + "07019": "AB890X", + "07020": "AB890X", + "07021": "AB890X", + "07022": "AB890X", + "07023": "AB890X", + "07024": "AB890X", + "07026": "AB890X", + "07027": "AB890X", + "07028": "AB890X", + "07029": "AB890X", + "07030": "AB890X", + "07031": "AB890X", + "07032": "AB890X", + "07033": "AB890X", + "07034": "AB890X", + "07035": "AB890X", + "07036": "AB890X", + "07039": "AB890X", + "07040": "AB890X", + "07041": "AB890X", + "07042": "AB890X", + "07043": "AB890X", + "07044": "AB890X", + "07045": "AB890X", + "07046": "AB890X", + "07047": "AB890X", + "07050": "AB890X", + "07051": "AB890X", + "07052": "AB890X", + "07054": "AB890X", + "07055": "AB890X", + "07057": "AB890X", + "07058": "AB890X", + "07059": "AB890X", + "07060": "AB890X", + "07061": "AB890X", + "07062": "AB890X", + "07063": "AB890X", + "07064": "AB890X", + "07065": "AB890X", + "07066": "AB890X", + "07067": "AB890X", + "07068": "AB890X", + "07069": "AB890X", + "07070": "AB890X", + "07071": "AB890X", + "07072": "AB890X", + "07073": "AB890X", + "07074": "AB890X", + "07075": "AB890X", + "07076": "AB890X", + "07077": "AB890X", + "07078": "AB890X", + "07079": "AB890X", + "07080": "AB890X", + "07081": "AB890X", + "07082": "AB890X", + "07083": "AB890X", + "07086": "AB890X", + "07087": "AB890X", + "07088": "AB890X", + "07090": "AB890X", + "07091": "AB890X", + "07092": "AB890X", + "07093": "AB890X", + "07094": "AB890X", + "07095": "AB890X", + "07096": "AB890X", + "07097": "AB890X", + "07099": "AB890X", + "07101": "AB890X", + "07102": "AB890X", + "07103": "AB890X", + "07104": "AB890X", + "07105": "AB890X", + "07106": "AB890X", + "07107": "AB890X", + "07108": "AB890X", + "07109": "AB890X", + "07110": "AB890X", + "07111": "AB890X", + "07112": "AB890X", + "07114": "AB890X", + "07175": "AB890X", + "07182": "AB890X", + "07184": "AB890X", + "07188": "AB890X", + "07189": "AB890X", + "07191": "AB890X", + "07192": "AB890X", + "07193": "AB890X", + "07194": "AB890X", + "07195": "AB890X", + "07198": "AB890X", + "07199": "AB890X", + "07201": "AB890X", + "07202": "AB890X", + "07203": "AB890X", + "07204": "AB890X", + "07205": "AB890X", + "07206": "AB890X", + "07207": "AB890X", + "07208": "AB890X", + "07302": "AB890X", + "07303": "AB890X", + "07304": "AB890X", + "07305": "AB890X", + "07306": "AB890X", + "07307": "AB890X", + "07308": "AB890X", + "07309": "AB890X", + "07310": "AB890X", + "07311": "AB890X", + "07395": "AB890X", + "07399": "AB890X", + "07401": "AB890X", + "07403": "AB890X", + "07405": "AB890X", + "07407": "AB890X", + "07410": "AB890X", + "07416": "AB890X", + "07417": "AB890X", + "07418": "AB890X", + "07419": "AB890X", + "07420": "AB890X", + "07421": "AB890X", + "07422": "AB890X", + "07423": "AB890X", + "07424": "AB890X", + "07428": "AB890X", + "07430": "AB890X", + "07432": "AB890X", + "07435": "AB890X", + "07436": "AB890X", + "07438": "AB890X", + "07439": "AB890X", + "07440": "AB890X", + "07442": "AB890X", + "07444": "AB890X", + "07446": "AB890X", + "07450": "AB890X", + "07451": "AB890X", + "07452": "AB890X", + "07456": "AB890X", + "07457": "AB890X", + "07458": "AB890X", + "07460": "AB890X", + "07461": "AB890X", + "07462": "AB890X", + "07463": "AB890X", + "07465": "AB890X", + "07470": "AB890X", + "07474": "AB890X", + "07477": "AB890X", + "07480": "AB890X", + "07481": "AB890X", + "07495": "AB890X", + "07501": "AB890X", + "07502": "AB890X", + "07503": "AB890X", + "07504": "AB890X", + "07505": "AB890X", + "07506": "AB890X", + "07507": "AB890X", + "07508": "AB890X", + "07509": "AB890X", + "07510": "AB890X", + "07511": "AB890X", + "07512": "AB890X", + "07513": "AB890X", + "07514": "AB890X", + "07522": "AB890X", + "07524": "AB890X", + "07533": "AB890X", + "07538": "AB890X", + "07543": "AB890X", + "07544": "AB890X", + "07601": "AB890X", + "07602": "AB890X", + "07603": "AB890X", + "07604": "AB890X", + "07605": "AB890X", + "07606": "AB890X", + "07607": "AB890X", + "07608": "AB890X", + "07620": "AB890X", + "07621": "AB890X", + "07624": "AB890X", + "07626": "AB890X", + "07627": "AB890X", + "07628": "AB890X", + "07630": "AB890X", + "07631": "AB890X", + "07632": "AB890X", + "07640": "AB890X", + "07641": "AB890X", + "07642": "AB890X", + "07643": "AB890X", + "07644": "AB890X", + "07645": "AB890X", + "07646": "AB890X", + "07647": "AB890X", + "07648": "AB890X", + "07649": "AB890X", + "07650": "AB890X", + "07652": "AB890X", + "07653": "AB890X", + "07656": "AB890X", + "07657": "AB890X", + "07660": "AB890X", + "07661": "AB890X", + "07662": "AB890X", + "07663": "AB890X", + "07666": "AB890X", + "07670": "AB890X", + "07675": "AB890X", + "07676": "AB890X", + "07677": "AB890X", + "07699": "AB890X", + "07701": "AB890X", + "07702": "AB890X", + "07703": "AB890X", + "07704": "AB890X", + "07709": "AB890X", + "07710": "AB890X", + "07711": "AB890X", + "07712": "AB890X", + "07715": "AB890X", + "07716": "AB890X", + "07717": "AB890X", + "07718": "AB890X", + "07719": "AB890X", + "07720": "AB890X", + "07721": "AB890X", + "07722": "AB890X", + "07723": "AB890X", + "07724": "AB890X", + "07726": "AB890X", + "07727": "AB890X", + "07728": "AB890X", + "07730": "AB890X", + "07731": "AB890X", + "07732": "AB890X", + "07733": "AB890X", + "07734": "AB890X", + "07735": "AB890X", + "07737": "AB890X", + "07738": "AB890X", + "07739": "AB890X", + "07740": "AB890X", + "07746": "AB890X", + "07747": "AB890X", + "07748": "AB890X", + "07750": "AB890X", + "07751": "AB890X", + "07752": "AB890X", + "07753": "AB890X", + "07754": "AB890X", + "07755": "AB890X", + "07756": "AB890X", + "07757": "AB890X", + "07758": "AB890X", + "07760": "AB890X", + "07762": "AB890X", + "07763": "AB890X", + "07764": "AB890X", + "07765": "AB890X", + "07777": "AB890X", + "07799": "AB890X", + "07801": "AB890X", + "07802": "AB890X", + "07803": "AB890X", + "07806": "AB890X", + "07820": "AB890X", + "07821": "AB890X", + "07822": "AB890X", + "07823": "AB890X", + "07825": "AB890X", + "07826": "AB890X", + "07827": "AB890X", + "07828": "AB890X", + "07829": "AB890X", + "07830": "AB890X", + "07831": "AB890X", + "07832": "AB890X", + "07833": "AB890X", + "07834": "AB890X", + "07836": "AB890X", + "07837": "AB890X", + "07838": "AB890X", + "07839": "AB890X", + "07840": "AB890X", + "07842": "AB890X", + "07843": "AB890X", + "07844": "AB890X", + "07845": "AB890X", + "07846": "AB890X", + "07847": "AB890X", + "07848": "AB890X", + "07849": "AB890X", + "07850": "AB890X", + "07851": "AB890X", + "07852": "AB890X", + "07853": "AB890X", + "07855": "AB890X", + "07856": "AB890X", + "07857": "AB890X", + "07860": "AB890X", + "07863": "AB890X", + "07865": "AB890X", + "07866": "AB890X", + "07869": "AB890X", + "07870": "AB890X", + "07871": "AB890X", + "07874": "AB890X", + "07875": "AB890X", + "07876": "AB890X", + "07877": "AB890X", + "07878": "AB890X", + "07879": "AB890X", + "07880": "AB890X", + "07881": "AB890X", + "07882": "AB890X", + "07885": "AB890X", + "07890": "AB890X", + "07901": "AB890X", + "07902": "AB890X", + "07920": "AB890X", + "07921": "AB890X", + "07922": "AB890X", + "07924": "AB890X", + "07926": "AB890X", + "07927": "AB890X", + "07928": "AB890X", + "07930": "AB890X", + "07931": "AB890X", + "07932": "AB890X", + "07933": "AB890X", + "07934": "AB890X", + "07935": "AB890X", + "07936": "AB890X", + "07938": "AB890X", + "07939": "AB890X", + "07940": "AB890X", + "07945": "AB890X", + "07946": "AB890X", + "07950": "AB890X", + "07960": "AB890X", + "07961": "AB890X", + "07962": "AB890X", + "07963": "AB890X", + "07970": "AB890X", + "07974": "AB890X", + "07976": "AB890X", + "07977": "AB890X", + "07978": "AB890X", + "07979": "AB890X", + "07980": "AB890X", + "07981": "AB890X", + "07983": "AB890X", + "07999": "AB890X", + "08001": "AB890X", + "08002": "AB890X", + "08003": "AB890X", + "08004": "AB890X", + "08005": "AB890X", + "08006": "AB890X", + "08007": "AB890X", + "08008": "AB890X", + "08009": "AB890X", + "08010": "AB890X", + "08011": "AB890X", + "08012": "AB890X", + "08014": "AB890X", + "08015": "AB890X", + "08016": "AB890X", + "08018": "AB890X", + "08019": "AB890X", + "08020": "AB890X", + "08021": "AB890X", + "08022": "AB890X", + "08023": "AB890X", + "08025": "AB890X", + "08026": "AB890X", + "08027": "AB890X", + "08028": "AB890X", + "08029": "AB890X", + "08030": "AB890X", + "08031": "AB890X", + "08032": "AB890X", + "08033": "AB890X", + "08034": "AB890X", + "08035": "AB890X", + "08036": "AB890X", + "08037": "AB890X", + "08038": "AB890X", + "08039": "AB890X", + "08041": "AB890X", + "08042": "AB890X", + "08043": "AB890X", + "08045": "AB890X", + "08046": "AB890X", + "08048": "AB890X", + "08049": "AB890X", + "08050": "AB890X", + "08051": "AB890X", + "08052": "AB890X", + "08053": "AB890X", + "08054": "AB890X", + "08055": "AB890X", + "08056": "AB890X", + "08057": "AB890X", + "08059": "AB890X", + "08060": "AB890X", + "08061": "AB890X", + "08062": "AB890X", + "08063": "AB890X", + "08064": "AB890X", + "08065": "AB890X", + "08066": "AB890X", + "08067": "AB890X", + "08068": "AB890X", + "08069": "AB890X", + "08070": "AB890X", + "08071": "AB890X", + "08072": "AB890X", + "08073": "AB890X", + "08074": "AB890X", + "08075": "AB890X", + "08076": "AB890X", + "08077": "AB890X", + "08078": "AB890X", + "08079": "AB890X", + "08080": "AB890X", + "08081": "AB890X", + "08083": "AB890X", + "08084": "AB890X", + "08085": "AB890X", + "08086": "AB890X", + "08087": "AB890X", + "08088": "AB890X", + "08089": "AB890X", + "08090": "AB890X", + "08091": "AB890X", + "08092": "AB890X", + "08093": "AB890X", + "08094": "AB890X", + "08095": "AB890X", + "08096": "AB890X", + "08097": "AB890X", + "08098": "AB890X", + "08099": "AB890X", + "08101": "AB890X", + "08102": "AB890X", + "08103": "AB890X", + "08104": "AB890X", + "08105": "AB890X", + "08106": "AB890X", + "08107": "AB890X", + "08108": "AB890X", + "08109": "AB890X", + "08110": "AB890X", + "08201": "AB890X", + "08202": "AB890X", + "08203": "AB890X", + "08204": "AB890X", + "08205": "AB890X", + "08210": "AB890X", + "08212": "AB890X", + "08213": "AB890X", + "08214": "AB890X", + "08215": "AB890X", + "08217": "AB890X", + "08218": "AB890X", + "08219": "AB890X", + "08220": "AB890X", + "08221": "AB890X", + "08223": "AB890X", + "08224": "AB890X", + "08225": "AB890X", + "08226": "AB890X", + "08230": "AB890X", + "08231": "AB890X", + "08232": "AB890X", + "08234": "AB890X", + "08240": "AB890X", + "08241": "AB890X", + "08242": "AB890X", + "08243": "AB890X", + "08244": "AB890X", + "08245": "AB890X", + "08246": "AB890X", + "08247": "AB890X", + "08248": "AB890X", + "08250": "AB890X", + "08251": "AB890X", + "08252": "AB890X", + "08260": "AB890X", + "08270": "AB890X", + "08302": "AB890X", + "08310": "AB890X", + "08311": "AB890X", + "08312": "AB890X", + "08313": "AB890X", + "08314": "AB890X", + "08315": "AB890X", + "08316": "AB890X", + "08317": "AB890X", + "08318": "AB890X", + "08319": "AB890X", + "08320": "AB890X", + "08321": "AB890X", + "08322": "AB890X", + "08323": "AB890X", + "08324": "AB890X", + "08326": "AB890X", + "08327": "AB890X", + "08328": "AB890X", + "08329": "AB890X", + "08330": "AB890X", + "08332": "AB890X", + "08340": "AB890X", + "08341": "AB890X", + "08342": "AB890X", + "08343": "AB890X", + "08344": "AB890X", + "08345": "AB890X", + "08346": "AB890X", + "08347": "AB890X", + "08348": "AB890X", + "08349": "AB890X", + "08350": "AB890X", + "08352": "AB890X", + "08353": "AB890X", + "08360": "AB890X", + "08361": "AB890X", + "08362": "AB890X", + "08401": "AB890X", + "08402": "AB890X", + "08403": "AB890X", + "08404": "AB890X", + "08405": "AB890X", + "08406": "AB890X", + "08501": "AB890X", + "08502": "AB890X", + "08504": "AB890X", + "08505": "AB890X", + "08510": "AB890X", + "08511": "AB890X", + "08512": "AB890X", + "08514": "AB890X", + "08515": "AB890X", + "08518": "AB890X", + "08520": "AB890X", + "08525": "AB890X", + "08526": "AB890X", + "08527": "AB890X", + "08528": "AB890X", + "08530": "AB890X", + "08533": "AB890X", + "08534": "AB890X", + "08535": "AB890X", + "08536": "AB890X", + "08540": "AB890X", + "08541": "AB890X", + "08542": "AB890X", + "08543": "AB890X", + "08544": "AB890X", + "08550": "AB890X", + "08551": "AB890X", + "08553": "AB890X", + "08554": "AB890X", + "08555": "AB890X", + "08556": "AB890X", + "08557": "AB890X", + "08558": "AB890X", + "08559": "AB890X", + "08560": "AB890X", + "08561": "AB890X", + "08562": "AB890X", + "08601": "AB890X", + "08602": "AB890X", + "08603": "AB890X", + "08604": "AB890X", + "08605": "AB890X", + "08606": "AB890X", + "08607": "AB890X", + "08608": "AB890X", + "08609": "AB890X", + "08610": "AB890X", + "08611": "AB890X", + "08618": "AB890X", + "08619": "AB890X", + "08620": "AB890X", + "08625": "AB890X", + "08628": "AB890X", + "08629": "AB890X", + "08638": "AB890X", + "08640": "AB890X", + "08641": "AB890X", + "08645": "AB890X", + "08646": "AB890X", + "08647": "AB890X", + "08648": "AB890X", + "08650": "AB890X", + "08666": "AB890X", + "08677": "AB890X", + "08690": "AB890X", + "08691": "AB890X", + "08695": "AB890X", + "08701": "AB890X", + "08720": "AB890X", + "08721": "AB890X", + "08722": "AB890X", + "08723": "AB890X", + "08724": "AB890X", + "08730": "AB890X", + "08731": "AB890X", + "08732": "AB890X", + "08733": "AB890X", + "08734": "AB890X", + "08735": "AB890X", + "08736": "AB890X", + "08738": "AB890X", + "08739": "AB890X", + "08740": "AB890X", + "08741": "AB890X", + "08742": "AB890X", + "08750": "AB890X", + "08751": "AB890X", + "08752": "AB890X", + "08753": "AB890X", + "08754": "AB890X", + "08755": "AB890X", + "08756": "AB890X", + "08757": "AB890X", + "08758": "AB890X", + "08759": "AB890X", + "08801": "AB890X", + "08802": "AB890X", + "08803": "AB890X", + "08804": "AB890X", + "08805": "AB890X", + "08807": "AB890X", + "08808": "AB890X", + "08809": "AB890X", + "08810": "AB890X", + "08812": "AB890X", + "08816": "AB890X", + "08817": "AB890X", + "08818": "AB890X", + "08820": "AB890X", + "08821": "AB890X", + "08822": "AB890X", + "08823": "AB890X", + "08824": "AB890X", + "08825": "AB890X", + "08826": "AB890X", + "08827": "AB890X", + "08828": "AB890X", + "08829": "AB890X", + "08830": "AB890X", + "08831": "AB890X", + "08832": "AB890X", + "08833": "AB890X", + "08834": "AB890X", + "08835": "AB890X", + "08836": "AB890X", + "08837": "AB890X", + "08840": "AB890X", + "08844": "AB890X", + "08846": "AB890X", + "08848": "AB890X", + "08850": "AB890X", + "08852": "AB890X", + "08853": "AB890X", + "08854": "AB890X", + "08855": "AB890X", + "08857": "AB890X", + "08858": "AB890X", + "08859": "AB890X", + "08861": "AB890X", + "08862": "AB890X", + "08863": "AB890X", + "08865": "AB890X", + "08867": "AB890X", + "08868": "AB890X", + "08869": "AB890X", + "08870": "AB890X", + "08871": "AB890X", + "08872": "AB890X", + "08873": "AB890X", + "08875": "AB890X", + "08876": "AB890X", + "08879": "AB890X", + "08880": "AB890X", + "08882": "AB890X", + "08884": "AB890X", + "08885": "AB890X", + "08886": "AB890X", + "08887": "AB890X", + "08888": "AB890X", + "08889": "AB890X", + "08890": "AB890X", + "08896": "AB890X", + "08899": "AB890X", + "08901": "AB890X", + "08902": "AB890X", + "08903": "AB890X", + "08904": "AB890X", + "08905": "AB890X", + "08906": "AB890X", + "08922": "AB890X", + "08933": "AB890X", + "08988": "AB890X", + "08989": "AB890X", + "10001": "AB890X", + "10002": "AB890X", + "10003": "AB890X", + "10004": "AB890X", + "10005": "AB890X", + "10006": "AB890X", + "10007": "AB890X", + "10008": "AB890X", + "10009": "AB890X", + "10010": "AB890X", + "10011": "AB890X", + "10012": "AB890X", + "10013": "AB890X", + "10014": "AB890X", + "10015": "AB890X", + "10016": "AB890X", + "10017": "AB890X", + "10018": "AB890X", + "10019": "AB890X", + "10020": "AB890X", + "10021": "AB890X", + "10022": "AB890X", + "10023": "AB890X", + "10024": "AB890X", + "10025": "AB890X", + "10026": "AB890X", + "10027": "AB890X", + "10028": "AB890X", + "10029": "AB890X", + "10030": "AB890X", + "10031": "AB890X", + "10032": "AB890X", + "10033": "AB890X", + "10034": "AB890X", + "10035": "AB890X", + "10036": "AB890X", + "10037": "AB890X", + "10038": "AB890X", + "10039": "AB890X", + "10040": "AB890X", + "10041": "AB890X", + "10043": "AB890X", + "10044": "AB890X", + "10045": "AB890X", + "10046": "AB890X", + "10047": "AB890X", + "10048": "AB890X", + "10055": "AB890X", + "10060": "AB890X", + "10069": "AB890X", + "10072": "AB890X", + "10079": "AB890X", + "10080": "AB890X", + "10081": "AB890X", + "10082": "AB890X", + "10087": "AB890X", + "10090": "AB890X", + "10094": "AB890X", + "10095": "AB890X", + "10096": "AB890X", + "10098": "AB890X", + "10099": "AB890X", + "10101": "AB890X", + "10102": "AB890X", + "10103": "AB890X", + "10104": "AB890X", + "10105": "AB890X", + "10106": "AB890X", + "10107": "AB890X", + "10108": "AB890X", + "10109": "AB890X", + "10110": "AB890X", + "10111": "AB890X", + "10112": "AB890X", + "10113": "AB890X", + "10114": "AB890X", + "10115": "AB890X", + "10116": "AB890X", + "10117": "AB890X", + "10118": "AB890X", + "10119": "AB890X", + "10120": "AB890X", + "10121": "AB890X", + "10122": "AB890X", + "10123": "AB890X", + "10124": "AB890X", + "10125": "AB890X", + "10126": "AB890X", + "10128": "AB890X", + "10129": "AB890X", + "10130": "AB890X", + "10131": "AB890X", + "10132": "AB890X", + "10133": "AB890X", + "10138": "AB890X", + "10149": "AB890X", + "10150": "AB890X", + "10151": "AB890X", + "10152": "AB890X", + "10153": "AB890X", + "10154": "AB890X", + "10155": "AB890X", + "10156": "AB890X", + "10157": "AB890X", + "10158": "AB890X", + "10159": "AB890X", + "10160": "AB890X", + "10161": "AB890X", + "10162": "AB890X", + "10163": "AB890X", + "10164": "AB890X", + "10165": "AB890X", + "10166": "AB890X", + "10167": "AB890X", + "10168": "AB890X", + "10169": "AB890X", + "10170": "AB890X", + "10171": "AB890X", + "10172": "AB890X", + "10173": "AB890X", + "10174": "AB890X", + "10175": "AB890X", + "10176": "AB890X", + "10177": "AB890X", + "10178": "AB890X", + "10179": "AB890X", + "10184": "AB890X", + "10185": "AB890X", + "10196": "AB890X", + "10197": "AB890X", + "10199": "AB890X", + "10203": "AB890X", + "10211": "AB890X", + "10212": "AB890X", + "10213": "AB890X", + "10242": "AB890X", + "10249": "AB890X", + "10256": "AB890X", + "10257": "AB890X", + "10258": "AB890X", + "10259": "AB890X", + "10260": "AB890X", + "10261": "AB890X", + "10265": "AB890X", + "10268": "AB890X", + "10269": "AB890X", + "10270": "AB890X", + "10271": "AB890X", + "10272": "AB890X", + "10273": "AB890X", + "10274": "AB890X", + "10275": "AB890X", + "10276": "AB890X", + "10277": "AB890X", + "10278": "AB890X", + "10279": "AB890X", + "10280": "AB890X", + "10281": "AB890X", + "10282": "AB890X", + "10285": "AB890X", + "10286": "AB890X", + "10292": "AB890X", + "10301": "AB890X", + "10302": "AB890X", + "10303": "AB890X", + "10304": "AB890X", + "10305": "AB890X", + "10306": "AB890X", + "10307": "AB890X", + "10308": "AB890X", + "10309": "AB890X", + "10310": "AB890X", + "10311": "AB890X", + "10312": "AB890X", + "10313": "AB890X", + "10314": "AB890X", + "10451": "AB890X", + "10452": "AB890X", + "10453": "AB890X", + "10454": "AB890X", + "10455": "AB890X", + "10456": "AB890X", + "10457": "AB890X", + "10458": "AB890X", + "10459": "AB890X", + "10460": "AB890X", + "10461": "AB890X", + "10462": "AB890X", + "10463": "AB890X", + "10464": "AB890X", + "10465": "AB890X", + "10466": "AB890X", + "10467": "AB890X", + "10468": "AB890X", + "10469": "AB890X", + "10470": "AB890X", + "10471": "AB890X", + "10472": "AB890X", + "10473": "AB890X", + "10474": "AB890X", + "10475": "AB890X", + "10499": "AB890X", + "10501": "AB890X", + "10502": "AB890X", + "10503": "AB890X", + "10504": "AB890X", + "10505": "AB890X", + "10506": "AB890X", + "10507": "AB890X", + "10509": "AB890X", + "10510": "AB890X", + "10511": "AB890X", + "10512": "AB890X", + "10514": "AB890X", + "10516": "AB890X", + "10517": "AB890X", + "10518": "AB890X", + "10519": "AB890X", + "10520": "AB890X", + "10521": "AB890X", + "10522": "AB890X", + "10523": "AB890X", + "10524": "AB890X", + "10526": "AB890X", + "10527": "AB890X", + "10528": "AB890X", + "10530": "AB890X", + "10532": "AB890X", + "10533": "AB890X", + "10535": "AB890X", + "10536": "AB890X", + "10537": "AB890X", + "10538": "AB890X", + "10540": "AB890X", + "10541": "AB890X", + "10542": "AB890X", + "10543": "AB890X", + "10545": "AB890X", + "10546": "AB890X", + "10547": "AB890X", + "10548": "AB890X", + "10549": "AB890X", + "10550": "AB890X", + "10551": "AB890X", + "10552": "AB890X", + "10553": "AB890X", + "10557": "AB890X", + "10558": "AB890X", + "10560": "AB890X", + "10562": "AB890X", + "10566": "AB890X", + "10567": "AB890X", + "10570": "AB890X", + "10571": "AB890X", + "10572": "AB890X", + "10573": "AB890X", + "10576": "AB890X", + "10577": "AB890X", + "10578": "AB890X", + "10579": "AB890X", + "10580": "AB890X", + "10583": "AB890X", + "10587": "AB890X", + "10588": "AB890X", + "10589": "AB890X", + "10590": "AB890X", + "10591": "AB890X", + "10594": "AB890X", + "10595": "AB890X", + "10596": "AB890X", + "10597": "AB890X", + "10598": "AB890X", + "10601": "AB890X", + "10602": "AB890X", + "10603": "AB890X", + "10604": "AB890X", + "10605": "AB890X", + "10606": "AB890X", + "10607": "AB890X", + "10610": "AB890X", + "10701": "AB890X", + "10702": "AB890X", + "10703": "AB890X", + "10704": "AB890X", + "10705": "AB890X", + "10706": "AB890X", + "10707": "AB890X", + "10708": "AB890X", + "10709": "AB890X", + "10710": "AB890X", + "10801": "AB890X", + "10802": "AB890X", + "10803": "AB890X", + "10804": "AB890X", + "10805": "AB890X", + "10901": "AB890X", + "10910": "AB890X", + "10911": "AB890X", + "10912": "AB890X", + "10913": "AB890X", + "10914": "AB890X", + "10915": "AB890X", + "10916": "AB890X", + "10917": "AB890X", + "10918": "AB890X", + "10919": "AB890X", + "10920": "AB890X", + "10921": "AB890X", + "10922": "AB890X", + "10923": "AB890X", + "10924": "AB890X", + "10925": "AB890X", + "10926": "AB890X", + "10927": "AB890X", + "10928": "AB890X", + "10930": "AB890X", + "10931": "AB890X", + "10932": "AB890X", + "10933": "AB890X", + "10940": "AB890X", + "10941": "AB890X", + "10943": "AB890X", + "10949": "AB890X", + "10950": "AB890X", + "10952": "AB890X", + "10953": "AB890X", + "10954": "AB890X", + "10956": "AB890X", + "10958": "AB890X", + "10959": "AB890X", + "10960": "AB890X", + "10962": "AB890X", + "10963": "AB890X", + "10964": "AB890X", + "10965": "AB890X", + "10968": "AB890X", + "10969": "AB890X", + "10970": "AB890X", + "10973": "AB890X", + "10974": "AB890X", + "10975": "AB890X", + "10976": "AB890X", + "10977": "AB890X", + "10979": "AB890X", + "10980": "AB890X", + "10981": "AB890X", + "10982": "AB890X", + "10983": "AB890X", + "10984": "AB890X", + "10985": "AB890X", + "10986": "AB890X", + "10987": "AB890X", + "10988": "AB890X", + "10989": "AB890X", + "10990": "AB890X", + "10992": "AB890X", + "10993": "AB890X", + "10994": "AB890X", + "10996": "AB890X", + "10997": "AB890X", + "10998": "AB890X", + "11001": "AB890X", + "11002": "AB890X", + "11003": "AB890X", + "11004": "AB890X", + "11005": "AB890X", + "11010": "AB890X", + "11020": "AB890X", + "11021": "AB890X", + "11022": "AB890X", + "11023": "AB890X", + "11024": "AB890X", + "11025": "AB890X", + "11026": "AB890X", + "11027": "AB890X", + "11030": "AB890X", + "11040": "AB890X", + "11041": "AB890X", + "11042": "AB890X", + "11043": "AB890X", + "11044": "AB890X", + "11050": "AB890X", + "11051": "AB890X", + "11052": "AB890X", + "11053": "AB890X", + "11054": "AB890X", + "11055": "AB890X", + "11096": "AB890X", + "11099": "AB890X", + "11101": "AB890X", + "11102": "AB890X", + "11103": "AB890X", + "11104": "AB890X", + "11105": "AB890X", + "11106": "AB890X", + "11109": "AB890X", + "11120": "AB890X", + "11201": "AB890X", + "11202": "AB890X", + "11203": "AB890X", + "11204": "AB890X", + "11205": "AB890X", + "11206": "AB890X", + "11207": "AB890X", + "11208": "AB890X", + "11209": "AB890X", + "11210": "AB890X", + "11211": "AB890X", + "11212": "AB890X", + "11213": "AB890X", + "11214": "AB890X", + "11215": "AB890X", + "11216": "AB890X", + "11217": "AB890X", + "11218": "AB890X", + "11219": "AB890X", + "11220": "AB890X", + "11221": "AB890X", + "11222": "AB890X", + "11223": "AB890X", + "11224": "AB890X", + "11225": "AB890X", + "11226": "AB890X", + "11228": "AB890X", + "11229": "AB890X", + "11230": "AB890X", + "11231": "AB890X", + "11232": "AB890X", + "11233": "AB890X", + "11234": "AB890X", + "11235": "AB890X", + "11236": "AB890X", + "11237": "AB890X", + "11238": "AB890X", + "11239": "AB890X", + "11240": "AB890X", + "11241": "AB890X", + "11242": "AB890X", + "11243": "AB890X", + "11244": "AB890X", + "11245": "AB890X", + "11247": "AB890X", + "11248": "AB890X", + "11249": "AB890X", + "11251": "AB890X", + "11252": "AB890X", + "11254": "AB890X", + "11255": "AB890X", + "11256": "AB890X", + "11351": "AB890X", + "11352": "AB890X", + "11354": "AB890X", + "11355": "AB890X", + "11356": "AB890X", + "11357": "AB890X", + "11358": "AB890X", + "11359": "AB890X", + "11360": "AB890X", + "11361": "AB890X", + "11362": "AB890X", + "11363": "AB890X", + "11364": "AB890X", + "11365": "AB890X", + "11366": "AB890X", + "11367": "AB890X", + "11368": "AB890X", + "11369": "AB890X", + "11370": "AB890X", + "11371": "AB890X", + "11372": "AB890X", + "11373": "AB890X", + "11374": "AB890X", + "11375": "AB890X", + "11377": "AB890X", + "11378": "AB890X", + "11379": "AB890X", + "11380": "AB890X", + "11381": "AB890X", + "11385": "AB890X", + "11386": "AB890X", + "11390": "AB890X", + "11405": "AB890X", + "11411": "AB890X", + "11412": "AB890X", + "11413": "AB890X", + "11414": "AB890X", + "11415": "AB890X", + "11416": "AB890X", + "11417": "AB890X", + "11418": "AB890X", + "11419": "AB890X", + "11420": "AB890X", + "11421": "AB890X", + "11422": "AB890X", + "11423": "AB890X", + "11424": "AB890X", + "11425": "AB890X", + "11426": "AB890X", + "11427": "AB890X", + "11428": "AB890X", + "11429": "AB890X", + "11430": "AB890X", + "11431": "AB890X", + "11432": "AB890X", + "11433": "AB890X", + "11434": "AB890X", + "11435": "AB890X", + "11436": "AB890X", + "11439": "AB890X", + "11451": "AB890X", + "11499": "AB890X", + "11501": "AB890X", + "11507": "AB890X", + "11509": "AB890X", + "11510": "AB890X", + "11514": "AB890X", + "11516": "AB890X", + "11518": "AB890X", + "11520": "AB890X", + "11530": "AB890X", + "11531": "AB890X", + "11535": "AB890X", + "11536": "AB890X", + "11542": "AB890X", + "11545": "AB890X", + "11547": "AB890X", + "11548": "AB890X", + "11549": "AB890X", + "11550": "AB890X", + "11551": "AB890X", + "11552": "AB890X", + "11553": "AB890X", + "11554": "AB890X", + "11555": "AB890X", + "11556": "AB890X", + "11557": "AB890X", + "11558": "AB890X", + "11559": "AB890X", + "11560": "AB890X", + "11561": "AB890X", + "11563": "AB890X", + "11565": "AB890X", + "11566": "AB890X", + "11568": "AB890X", + "11569": "AB890X", + "11570": "AB890X", + "11571": "AB890X", + "11572": "AB890X", + "11575": "AB890X", + "11576": "AB890X", + "11577": "AB890X", + "11579": "AB890X", + "11580": "AB890X", + "11581": "AB890X", + "11582": "AB890X", + "11590": "AB890X", + "11592": "AB890X", + "11594": "AB890X", + "11595": "AB890X", + "11596": "AB890X", + "11597": "AB890X", + "11598": "AB890X", + "11599": "AB890X", + "11690": "AB890X", + "11691": "AB890X", + "11692": "AB890X", + "11693": "AB890X", + "11694": "AB890X", + "11695": "AB890X", + "11697": "AB890X", + "11701": "AB890X", + "11702": "AB890X", + "11703": "AB890X", + "11704": "AB890X", + "11705": "AB890X", + "11706": "AB890X", + "11707": "AB890X", + "11708": "AB890X", + "11709": "AB890X", + "11710": "AB890X", + "11713": "AB890X", + "11714": "AB890X", + "11715": "AB890X", + "11716": "AB890X", + "11717": "AB890X", + "11718": "AB890X", + "11719": "AB890X", + "11720": "AB890X", + "11721": "AB890X", + "11722": "AB890X", + "11724": "AB890X", + "11725": "AB890X", + "11726": "AB890X", + "11727": "AB890X", + "11729": "AB890X", + "11730": "AB890X", + "11731": "AB890X", + "11732": "AB890X", + "11733": "AB890X", + "11735": "AB890X", + "11736": "AB890X", + "11737": "AB890X", + "11738": "AB890X", + "11739": "AB890X", + "11740": "AB890X", + "11741": "AB890X", + "11742": "AB890X", + "11743": "AB890X", + "11746": "AB890X", + "11747": "AB890X", + "11749": "AB890X", + "11750": "AB890X", + "11751": "AB890X", + "11752": "AB890X", + "11753": "AB890X", + "11754": "AB890X", + "11755": "AB890X", + "11756": "AB890X", + "11757": "AB890X", + "11758": "AB890X", + "11760": "AB890X", + "11762": "AB890X", + "11763": "AB890X", + "11764": "AB890X", + "11765": "AB890X", + "11766": "AB890X", + "11767": "AB890X", + "11768": "AB890X", + "11769": "AB890X", + "11770": "AB890X", + "11771": "AB890X", + "11772": "AB890X", + "11773": "AB890X", + "11774": "AB890X", + "11775": "AB890X", + "11776": "AB890X", + "11777": "AB890X", + "11778": "AB890X", + "11779": "AB890X", + "11780": "AB890X", + "11782": "AB890X", + "11783": "AB890X", + "11784": "AB890X", + "11786": "AB890X", + "11787": "AB890X", + "11788": "AB890X", + "11789": "AB890X", + "11790": "AB890X", + "11791": "AB890X", + "11792": "AB890X", + "11793": "AB890X", + "11794": "AB890X", + "11795": "AB890X", + "11796": "AB890X", + "11797": "AB890X", + "11798": "AB890X", + "11801": "AB890X", + "11802": "AB890X", + "11803": "AB890X", + "11804": "AB890X", + "11815": "AB890X", + "11819": "AB890X", + "11853": "AB890X", + "11854": "AB890X", + "11855": "AB890X", + "11901": "AB890X", + "11930": "AB890X", + "11931": "AB890X", + "11932": "AB890X", + "11933": "AB890X", + "11934": "AB890X", + "11935": "AB890X", + "11937": "AB890X", + "11939": "AB890X", + "11940": "AB890X", + "11941": "AB890X", + "11942": "AB890X", + "11944": "AB890X", + "11946": "AB890X", + "11947": "AB890X", + "11948": "AB890X", + "11949": "AB890X", + "11950": "AB890X", + "11951": "AB890X", + "11952": "AB890X", + "11953": "AB890X", + "11954": "AB890X", + "11955": "AB890X", + "11956": "AB890X", + "11957": "AB890X", + "11958": "AB890X", + "11959": "AB890X", + "11960": "AB890X", + "11961": "AB890X", + "11962": "AB890X", + "11963": "AB890X", + "11964": "AB890X", + "11965": "AB890X", + "11967": "AB890X", + "11968": "AB890X", + "11969": "AB890X", + "11970": "AB890X", + "11971": "AB890X", + "11972": "AB890X", + "11973": "AB890X", + "11975": "AB890X", + "11976": "AB890X", + "11977": "AB890X", + "11978": "AB890X", + "11980": "AB890X", + "12007": "AB890X", + "12008": "AB890X", + "12009": "AB890X", + "12010": "AB890X", + "12015": "AB890X", + "12016": "AB890X", + "12017": "AB890X", + "12018": "AB890X", + "12019": "AB890X", + "12020": "AB890X", + "12022": "AB890X", + "12023": "AB890X", + "12024": "AB890X", + "12025": "AB890X", + "12027": "AB890X", + "12028": "AB890X", + "12029": "AB890X", + "12031": "AB890X", + "12032": "AB890X", + "12033": "AB890X", + "12035": "AB890X", + "12036": "AB890X", + "12037": "AB890X", + "12040": "AB890X", + "12041": "AB890X", + "12042": "AB890X", + "12043": "AB890X", + "12045": "AB890X", + "12046": "AB890X", + "12047": "AB890X", + "12050": "AB890X", + "12051": "AB890X", + "12052": "AB890X", + "12053": "AB890X", + "12054": "AB890X", + "12055": "AB890X", + "12056": "AB890X", + "12057": "AB890X", + "12058": "AB890X", + "12059": "AB890X", + "12060": "AB890X", + "12061": "AB890X", + "12062": "AB890X", + "12063": "AB890X", + "12064": "AB900X", + "12065": "AB890X", + "12066": "AB890X", + "12067": "AB890X", + "12068": "AB890X", + "12069": "AB890X", + "12070": "AB890X", + "12071": "AB890X", + "12072": "AB890X", + "12073": "AB890X", + "12074": "AB890X", + "12075": "AB890X", + "12076": "AB890X", + "12077": "AB890X", + "12078": "AB890X", + "12082": "AB890X", + "12083": "AB890X", + "12084": "AB890X", + "12085": "AB890X", + "12086": "AB890X", + "12087": "AB890X", + "12089": "AB890X", + "12090": "AB890X", + "12092": "AB890X", + "12093": "AB900X", + "12094": "AB890X", + "12095": "AB890X", + "12106": "AB890X", + "12107": "AB890X", + "12108": "AB890X", + "12110": "AB890X", + "12115": "AB890X", + "12116": "AB900X", + "12117": "AB890X", + "12118": "AB890X", + "12120": "AB890X", + "12121": "AB890X", + "12122": "AB890X", + "12123": "AB890X", + "12124": "AB890X", + "12125": "AB890X", + "12128": "AB890X", + "12130": "AB890X", + "12131": "AB890X", + "12132": "AB890X", + "12133": "AB890X", + "12134": "AB890X", + "12136": "AB890X", + "12137": "AB890X", + "12138": "AB890X", + "12139": "AB900X", + "12140": "AB890X", + "12141": "AB890X", + "12143": "AB890X", + "12144": "AB890X", + "12147": "AB890X", + "12148": "AB890X", + "12149": "AB890X", + "12150": "AB890X", + "12151": "AB890X", + "12153": "AB890X", + "12154": "AB890X", + "12155": "AB900X", + "12156": "AB890X", + "12157": "AB890X", + "12158": "AB890X", + "12159": "AB890X", + "12160": "AB890X", + "12161": "AB890X", + "12164": "AB890X", + "12165": "AB890X", + "12166": "AB890X", + "12167": "AB900X", + "12168": "AB890X", + "12169": "AB890X", + "12170": "AB890X", + "12172": "AB890X", + "12173": "AB890X", + "12174": "AB890X", + "12175": "AB890X", + "12176": "AB890X", + "12177": "AB890X", + "12180": "AB890X", + "12181": "AB890X", + "12182": "AB890X", + "12183": "AB890X", + "12184": "AB890X", + "12185": "AB890X", + "12186": "AB890X", + "12187": "AB890X", + "12188": "AB890X", + "12189": "AB890X", + "12190": "AB890X", + "12192": "AB890X", + "12193": "AB890X", + "12194": "AB890X", + "12195": "AB890X", + "12196": "AB890X", + "12197": "AB900X", + "12198": "AB890X", + "12201": "AB890X", + "12202": "AB890X", + "12203": "AB890X", + "12204": "AB890X", + "12205": "AB890X", + "12206": "AB890X", + "12207": "AB890X", + "12208": "AB890X", + "12209": "AB890X", + "12210": "AB890X", + "12211": "AB890X", + "12212": "AB890X", + "12214": "AB890X", + "12220": "AB890X", + "12222": "AB890X", + "12223": "AB890X", + "12224": "AB890X", + "12225": "AB890X", + "12226": "AB890X", + "12227": "AB890X", + "12228": "AB890X", + "12229": "AB890X", + "12230": "AB890X", + "12231": "AB890X", + "12232": "AB890X", + "12233": "AB890X", + "12234": "AB890X", + "12235": "AB890X", + "12236": "AB890X", + "12237": "AB890X", + "12238": "AB890X", + "12239": "AB890X", + "12240": "AB890X", + "12241": "AB890X", + "12242": "AB890X", + "12243": "AB890X", + "12244": "AB890X", + "12245": "AB890X", + "12246": "AB890X", + "12247": "AB890X", + "12248": "AB890X", + "12249": "AB890X", + "12250": "AB890X", + "12252": "AB890X", + "12255": "AB890X", + "12256": "AB890X", + "12257": "AB890X", + "12260": "AB890X", + "12261": "AB890X", + "12288": "AB890X", + "12301": "AB890X", + "12302": "AB890X", + "12303": "AB890X", + "12304": "AB890X", + "12305": "AB890X", + "12306": "AB890X", + "12307": "AB890X", + "12308": "AB890X", + "12309": "AB890X", + "12325": "AB890X", + "12345": "AB890X", + "12401": "AB890X", + "12402": "AB890X", + "12404": "AB890X", + "12405": "AB890X", + "12406": "AB900X", + "12407": "AB890X", + "12409": "AB890X", + "12410": "AB890X", + "12411": "AB890X", + "12412": "AB890X", + "12413": "AB890X", + "12414": "AB890X", + "12416": "AB890X", + "12417": "AB890X", + "12418": "AB890X", + "12419": "AB890X", + "12420": "AB890X", + "12421": "AB900X", + "12422": "AB890X", + "12423": "AB890X", + "12424": "AB890X", + "12427": "AB890X", + "12428": "AB890X", + "12429": "AB890X", + "12430": "AB900X", + "12431": "AB890X", + "12432": "AB890X", + "12433": "AB890X", + "12434": "AB900X", + "12435": "AB890X", + "12436": "AB890X", + "12438": "AB900X", + "12439": "AB890X", + "12440": "AB890X", + "12441": "AB890X", + "12442": "AB890X", + "12443": "AB890X", + "12444": "AB890X", + "12446": "AB890X", + "12448": "AB890X", + "12449": "AB890X", + "12450": "AB890X", + "12451": "AB890X", + "12452": "AB890X", + "12453": "AB890X", + "12454": "AB890X", + "12455": "AB900X", + "12456": "AB890X", + "12457": "AB890X", + "12458": "AB890X", + "12459": "AB900X", + "12460": "AB890X", + "12461": "AB890X", + "12463": "AB890X", + "12464": "AB890X", + "12465": "AB890X", + "12466": "AB890X", + "12468": "AB900X", + "12469": "AB890X", + "12470": "AB890X", + "12471": "AB890X", + "12472": "AB890X", + "12473": "AB890X", + "12474": "AB900X", + "12475": "AB890X", + "12477": "AB890X", + "12480": "AB890X", + "12481": "AB890X", + "12482": "AB890X", + "12483": "AB890X", + "12484": "AB890X", + "12485": "AB890X", + "12486": "AB890X", + "12487": "AB890X", + "12489": "AB890X", + "12490": "AB890X", + "12491": "AB890X", + "12492": "AB890X", + "12493": "AB890X", + "12494": "AB890X", + "12495": "AB890X", + "12496": "AB890X", + "12498": "AB890X", + "12501": "AB890X", + "12502": "AB890X", + "12503": "AB890X", + "12504": "AB890X", + "12506": "AB890X", + "12507": "AB890X", + "12508": "AB890X", + "12510": "AB890X", + "12511": "AB890X", + "12512": "AB890X", + "12513": "AB890X", + "12514": "AB890X", + "12515": "AB890X", + "12516": "AB890X", + "12517": "AB890X", + "12518": "AB890X", + "12520": "AB890X", + "12521": "AB890X", + "12522": "AB890X", + "12523": "AB890X", + "12524": "AB890X", + "12525": "AB890X", + "12526": "AB890X", + "12527": "AB890X", + "12528": "AB890X", + "12529": "AB890X", + "12530": "AB890X", + "12531": "AB890X", + "12533": "AB890X", + "12534": "AB890X", + "12537": "AB890X", + "12538": "AB890X", + "12540": "AB890X", + "12541": "AB890X", + "12542": "AB890X", + "12543": "AB890X", + "12544": "AB890X", + "12545": "AB890X", + "12546": "AB890X", + "12547": "AB890X", + "12548": "AB890X", + "12549": "AB890X", + "12550": "AB890X", + "12551": "AB890X", + "12552": "AB890X", + "12553": "AB890X", + "12555": "AB890X", + "12561": "AB890X", + "12563": "AB890X", + "12564": "AB890X", + "12565": "AB890X", + "12566": "AB890X", + "12567": "AB890X", + "12568": "AB890X", + "12569": "AB890X", + "12570": "AB890X", + "12571": "AB890X", + "12572": "AB890X", + "12574": "AB890X", + "12575": "AB890X", + "12577": "AB890X", + "12578": "AB890X", + "12580": "AB890X", + "12581": "AB890X", + "12582": "AB890X", + "12583": "AB890X", + "12584": "AB890X", + "12585": "AB890X", + "12586": "AB890X", + "12588": "AB890X", + "12589": "AB890X", + "12590": "AB890X", + "12592": "AB890X", + "12593": "AB890X", + "12594": "AB890X", + "12601": "AB890X", + "12602": "AB890X", + "12603": "AB890X", + "12604": "AB890X", + "12701": "AB890X", + "12719": "AB890X", + "12720": "AB890X", + "12721": "AB890X", + "12722": "AB890X", + "12723": "AB890X", + "12724": "AB890X", + "12725": "AB890X", + "12726": "AB890X", + "12727": "AB890X", + "12729": "AB890X", + "12732": "AB890X", + "12733": "AB890X", + "12734": "AB890X", + "12736": "AB890X", + "12737": "AB890X", + "12738": "AB890X", + "12740": "AB890X", + "12741": "AB890X", + "12742": "AB890X", + "12743": "AB890X", + "12745": "AB890X", + "12746": "AB890X", + "12747": "AB890X", + "12748": "AB890X", + "12749": "AB890X", + "12750": "AB890X", + "12751": "AB890X", + "12752": "AB890X", + "12754": "AB890X", + "12758": "AB890X", + "12759": "AB890X", + "12760": "AB890X", + "12762": "AB890X", + "12763": "AB890X", + "12764": "AB890X", + "12765": "AB890X", + "12766": "AB890X", + "12767": "AB890X", + "12768": "AB890X", + "12769": "AB890X", + "12770": "AB890X", + "12771": "AB890X", + "12775": "AB890X", + "12776": "AB890X", + "12777": "AB890X", + "12778": "AB890X", + "12779": "AB890X", + "12780": "AB890X", + "12781": "AB890X", + "12783": "AB890X", + "12784": "AB890X", + "12785": "AB890X", + "12786": "AB890X", + "12787": "AB890X", + "12788": "AB890X", + "12789": "AB890X", + "12790": "AB890X", + "12791": "AB890X", + "12792": "AB890X", + "12801": "AB890X", + "12803": "AB890X", + "12804": "AB890X", + "12808": "AB890X", + "12809": "AB890X", + "12810": "AB890X", + "12811": "AB890X", + "12812": "AB890X", + "12814": "AB890X", + "12815": "AB890X", + "12816": "AB890X", + "12817": "AB890X", + "12819": "AB890X", + "12820": "AB890X", + "12821": "AB890X", + "12822": "AB890X", + "12823": "AB890X", + "12824": "AB890X", + "12827": "AB890X", + "12828": "AB890X", + "12831": "AB890X", + "12832": "AB890X", + "12833": "AB890X", + "12834": "AB890X", + "12835": "AB890X", + "12836": "AB890X", + "12837": "AB890X", + "12838": "AB890X", + "12839": "AB890X", + "12841": "AB890X", + "12842": "AB890X", + "12843": "AB890X", + "12844": "AB890X", + "12845": "AB890X", + "12846": "AB890X", + "12847": "AB890X", + "12848": "AB890X", + "12849": "AB890X", + "12850": "AB890X", + "12851": "AB890X", + "12852": "AB890X", + "12853": "AB890X", + "12854": "AB890X", + "12855": "AB889X", + "12856": "AB890X", + "12857": "AB890X", + "12858": "AB889X", + "12859": "AB890X", + "12860": "AB890X", + "12861": "AB890X", + "12862": "AB890X", + "12863": "AB890X", + "12864": "AB890X", + "12865": "AB890X", + "12866": "AB890X", + "12870": "AB889X", + "12871": "AB890X", + "12872": "AB889X", + "12873": "AB890X", + "12874": "AB890X", + "12878": "AB890X", + "12879": "AB889X", + "12883": "AB889X", + "12884": "AB890X", + "12885": "AB890X", + "12886": "AB890X", + "12887": "AB890X", + "12901": "AB889X", + "12903": "AB889X", + "12910": "AB889X", + "12911": "AB889X", + "12912": "AB889X", + "12913": "AB889X", + "12914": "AB889X", + "12915": "AB889X", + "12916": "AB889X", + "12917": "AB889X", + "12918": "AB890X", + "12919": "AB889X", + "12920": "AB889X", + "12921": "AB889X", + "12922": "AB889X", + "12923": "AB889X", + "12924": "AB889X", + "12926": "AB889X", + "12927": "AB900X", + "12928": "AB889X", + "12929": "AB889X", + "12930": "AB889X", + "12932": "AB889X", + "12933": "AB889X", + "12934": "AB889X", + "12935": "AB889X", + "12936": "AB889X", + "12937": "AB889X", + "12939": "AB889X", + "12941": "AB889X", + "12942": "AB889X", + "12943": "AB889X", + "12944": "AB889X", + "12945": "AB889X", + "12946": "AB889X", + "12949": "AB889X", + "12950": "AB889X", + "12952": "AB889X", + "12953": "AB889X", + "12955": "AB889X", + "12956": "AB889X", + "12957": "AB889X", + "12958": "AB889X", + "12959": "AB889X", + "12960": "AB889X", + "12961": "AB889X", + "12962": "AB889X", + "12964": "AB889X", + "12965": "AB900X", + "12966": "AB889X", + "12967": "AB900X", + "12969": "AB889X", + "12970": "AB889X", + "12972": "AB889X", + "12973": "AB889X", + "12974": "AB889X", + "12975": "AB889X", + "12976": "AB889X", + "12977": "AB889X", + "12978": "AB889X", + "12979": "AB889X", + "12980": "AB889X", + "12981": "AB889X", + "12983": "AB889X", + "12985": "AB889X", + "12986": "AB900X", + "12987": "AB889X", + "12989": "AB889X", + "12992": "AB889X", + "12993": "AB889X", + "12995": "AB889X", + "12996": "AB889X", + "12997": "AB889X", + "12998": "AB889X", + "13020": "AB900X", + "13021": "AB900X", + "13022": "AB900X", + "13024": "AB900X", + "13026": "AB900X", + "13027": "AB900X", + "13028": "AB900X", + "13029": "AB900X", + "13030": "AB900X", + "13031": "AB900X", + "13032": "AB900X", + "13033": "AB900X", + "13034": "AB900X", + "13035": "AB900X", + "13036": "AB900X", + "13037": "AB900X", + "13039": "AB900X", + "13040": "AB890X", + "13041": "AB900X", + "13042": "AB900X", + "13043": "AB900X", + "13044": "AB900X", + "13045": "AB900X", + "13051": "AB900X", + "13052": "AB900X", + "13053": "AB900X", + "13054": "AB900X", + "13056": "AB890X", + "13057": "AB900X", + "13060": "AB900X", + "13061": "AB900X", + "13062": "AB900X", + "13063": "AB900X", + "13064": "AB900X", + "13065": "AB900X", + "13066": "AB900X", + "13068": "AB900X", + "13069": "AB900X", + "13071": "AB900X", + "13072": "AB900X", + "13073": "AB900X", + "13074": "AB900X", + "13076": "AB900X", + "13077": "AB890X", + "13078": "AB900X", + "13080": "AB900X", + "13081": "AB900X", + "13082": "AB900X", + "13083": "AB900X", + "13084": "AB900X", + "13087": "AB890X", + "13088": "AB900X", + "13089": "AB900X", + "13090": "AB900X", + "13092": "AB900X", + "13093": "AB900X", + "13101": "AB890X", + "13102": "AB900X", + "13103": "AB900X", + "13104": "AB900X", + "13107": "AB900X", + "13108": "AB900X", + "13110": "AB900X", + "13111": "AB900X", + "13112": "AB900X", + "13113": "AB900X", + "13114": "AB900X", + "13115": "AB900X", + "13116": "AB900X", + "13117": "AB900X", + "13118": "AB900X", + "13119": "AB900X", + "13120": "AB900X", + "13121": "AB900X", + "13122": "AB900X", + "13123": "AB900X", + "13124": "AB900X", + "13126": "AB900X", + "13131": "AB900X", + "13132": "AB900X", + "13134": "AB900X", + "13135": "AB900X", + "13136": "AB900X", + "13137": "AB900X", + "13138": "AB900X", + "13139": "AB900X", + "13140": "AB900X", + "13141": "AB890X", + "13142": "AB900X", + "13143": "AB900X", + "13144": "AB900X", + "13145": "AB900X", + "13146": "AB900X", + "13147": "AB900X", + "13148": "AB900X", + "13152": "AB900X", + "13153": "AB900X", + "13154": "AB900X", + "13155": "AB900X", + "13156": "AB900X", + "13157": "AB900X", + "13158": "AB900X", + "13159": "AB900X", + "13160": "AB900X", + "13162": "AB900X", + "13163": "AB900X", + "13164": "AB900X", + "13165": "AB900X", + "13166": "AB900X", + "13167": "AB900X", + "13201": "AB900X", + "13202": "AB900X", + "13203": "AB900X", + "13204": "AB900X", + "13205": "AB900X", + "13206": "AB900X", + "13207": "AB900X", + "13208": "AB900X", + "13209": "AB900X", + "13210": "AB900X", + "13211": "AB900X", + "13212": "AB900X", + "13214": "AB900X", + "13215": "AB900X", + "13217": "AB900X", + "13218": "AB900X", + "13219": "AB900X", + "13220": "AB900X", + "13221": "AB900X", + "13224": "AB900X", + "13225": "AB900X", + "13235": "AB900X", + "13244": "AB900X", + "13250": "AB900X", + "13251": "AB900X", + "13252": "AB900X", + "13261": "AB900X", + "13290": "AB900X", + "13301": "AB900X", + "13302": "AB900X", + "13303": "AB900X", + "13304": "AB900X", + "13305": "AB900X", + "13308": "AB900X", + "13309": "AB900X", + "13310": "AB900X", + "13312": "AB900X", + "13313": "AB900X", + "13314": "AB900X", + "13315": "AB900X", + "13316": "AB900X", + "13317": "AB890X", + "13318": "AB900X", + "13319": "AB900X", + "13320": "AB900X", + "13321": "AB900X", + "13322": "AB900X", + "13323": "AB900X", + "13324": "AB900X", + "13325": "AB900X", + "13326": "AB900X", + "13327": "AB900X", + "13328": "AB900X", + "13329": "AB900X", + "13331": "AB900X", + "13332": "AB890X", + "13333": "AB900X", + "13334": "AB900X", + "13335": "AB900X", + "13337": "AB900X", + "13338": "AB900X", + "13339": "AB890X", + "13340": "AB900X", + "13341": "AB900X", + "13342": "AB900X", + "13343": "AB900X", + "13345": "AB900X", + "13346": "AB900X", + "13348": "AB900X", + "13350": "AB900X", + "13352": "AB900X", + "13353": "AB890X", + "13354": "AB900X", + "13355": "AB900X", + "13357": "AB900X", + "13360": "AB900X", + "13361": "AB900X", + "13362": "AB900X", + "13363": "AB900X", + "13364": "AB900X", + "13365": "AB900X", + "13367": "AB900X", + "13368": "AB900X", + "13401": "AB900X", + "13402": "AB900X", + "13403": "AB900X", + "13404": "AB900X", + "13406": "AB900X", + "13407": "AB900X", + "13408": "AB900X", + "13409": "AB900X", + "13410": "AB900X", + "13411": "AB900X", + "13413": "AB900X", + "13415": "AB900X", + "13416": "AB900X", + "13417": "AB900X", + "13418": "AB900X", + "13420": "AB900X", + "13421": "AB900X", + "13424": "AB900X", + "13425": "AB900X", + "13426": "AB900X", + "13428": "AB890X", + "13431": "AB900X", + "13433": "AB900X", + "13435": "AB900X", + "13436": "AB890X", + "13437": "AB900X", + "13438": "AB900X", + "13439": "AB900X", + "13440": "AB900X", + "13441": "AB900X", + "13442": "AB900X", + "13449": "AB900X", + "13450": "AB900X", + "13452": "AB890X", + "13454": "AB900X", + "13455": "AB900X", + "13456": "AB900X", + "13457": "AB900X", + "13459": "AB890X", + "13460": "AB890X", + "13461": "AB900X", + "13464": "AB890X", + "13465": "AB900X", + "13468": "AB900X", + "13469": "AB900X", + "13470": "AB900X", + "13471": "AB900X", + "13472": "AB900X", + "13473": "AB900X", + "13475": "AB900X", + "13476": "AB900X", + "13477": "AB900X", + "13478": "AB900X", + "13479": "AB900X", + "13480": "AB900X", + "13482": "AB900X", + "13483": "AB900X", + "13484": "AB900X", + "13485": "AB900X", + "13486": "AB900X", + "13488": "AB900X", + "13489": "AB900X", + "13490": "AB900X", + "13491": "AB900X", + "13492": "AB900X", + "13493": "AB900X", + "13494": "AB900X", + "13495": "AB900X", + "13501": "AB900X", + "13502": "AB900X", + "13503": "AB900X", + "13504": "AB900X", + "13505": "AB900X", + "13599": "AB900X", + "13601": "AB900X", + "13602": "AB900X", + "13603": "AB900X", + "13605": "AB900X", + "13606": "AB900X", + "13607": "AB900X", + "13608": "AB900X", + "13611": "AB900X", + "13612": "AB900X", + "13613": "AB900X", + "13614": "AB900X", + "13615": "AB900X", + "13616": "AB900X", + "13617": "AB900X", + "13618": "AB900X", + "13619": "AB900X", + "13620": "AB900X", + "13621": "AB900X", + "13622": "AB900X", + "13623": "AB900X", + "13624": "AB900X", + "13625": "AB900X", + "13626": "AB900X", + "13627": "AB900X", + "13628": "AB900X", + "13630": "AB900X", + "13631": "AB900X", + "13632": "AB900X", + "13633": "AB900X", + "13634": "AB900X", + "13635": "AB900X", + "13636": "AB900X", + "13637": "AB900X", + "13638": "AB900X", + "13639": "AB900X", + "13640": "AB900X", + "13641": "AB900X", + "13642": "AB900X", + "13643": "AB900X", + "13645": "AB900X", + "13646": "AB900X", + "13647": "AB900X", + "13648": "AB900X", + "13649": "AB900X", + "13650": "AB900X", + "13651": "AB900X", + "13652": "AB900X", + "13654": "AB900X", + "13655": "AB900X", + "13656": "AB900X", + "13657": "AB900X", + "13658": "AB900X", + "13659": "AB900X", + "13660": "AB900X", + "13661": "AB900X", + "13662": "AB900X", + "13664": "AB900X", + "13665": "AB900X", + "13666": "AB900X", + "13667": "AB900X", + "13668": "AB900X", + "13669": "AB900X", + "13670": "AB900X", + "13671": "AB900X", + "13672": "AB900X", + "13673": "AB900X", + "13674": "AB900X", + "13675": "AB900X", + "13676": "AB900X", + "13677": "AB900X", + "13678": "AB900X", + "13679": "AB900X", + "13680": "AB900X", + "13681": "AB900X", + "13682": "AB900X", + "13683": "AB900X", + "13684": "AB900X", + "13685": "AB900X", + "13687": "AB900X", + "13690": "AB900X", + "13691": "AB900X", + "13692": "AB900X", + "13693": "AB900X", + "13694": "AB900X", + "13695": "AB900X", + "13696": "AB900X", + "13697": "AB900X", + "13699": "AB900X", + "13730": "AB890X", + "13731": "AB900X", + "13732": "AB890X", + "13733": "AB890X", + "13734": "AB890X", + "13736": "AB890X", + "13737": "AB890X", + "13738": "AB890X", + "13739": "AB900X", + "13740": "AB900X", + "13743": "AB890X", + "13744": "AB890X", + "13745": "AB890X", + "13746": "AB890X", + "13747": "AB900X", + "13748": "AB890X", + "13749": "AB890X", + "13750": "AB900X", + "13751": "AB900X", + "13752": "AB900X", + "13753": "AB900X", + "13754": "AB890X", + "13755": "AB890X", + "13756": "AB890X", + "13757": "AB900X", + "13758": "AB890X", + "13760": "AB890X", + "13761": "AB890X", + "13762": "AB890X", + "13763": "AB890X", + "13774": "AB900X", + "13775": "AB900X", + "13776": "AB900X", + "13777": "AB890X", + "13778": "AB890X", + "13780": "AB890X", + "13782": "AB900X", + "13783": "AB890X", + "13784": "AB890X", + "13786": "AB900X", + "13787": "AB890X", + "13788": "AB900X", + "13790": "AB890X", + "13794": "AB890X", + "13795": "AB890X", + "13796": "AB900X", + "13797": "AB890X", + "13801": "AB890X", + "13802": "AB890X", + "13803": "AB890X", + "13804": "AB900X", + "13806": "AB900X", + "13807": "AB900X", + "13808": "AB900X", + "13809": "AB900X", + "13810": "AB900X", + "13811": "AB890X", + "13812": "AB890X", + "13813": "AB890X", + "13814": "AB890X", + "13815": "AB890X", + "13820": "AB900X", + "13825": "AB900X", + "13826": "AB890X", + "13827": "AB890X", + "13830": "AB890X", + "13832": "AB890X", + "13833": "AB890X", + "13834": "AB900X", + "13835": "AB890X", + "13837": "AB900X", + "13838": "AB900X", + "13839": "AB900X", + "13840": "AB890X", + "13841": "AB890X", + "13842": "AB900X", + "13843": "AB900X", + "13844": "AB890X", + "13845": "AB890X", + "13846": "AB900X", + "13847": "AB900X", + "13848": "AB890X", + "13849": "AB900X", + "13850": "AB890X", + "13851": "AB890X", + "13856": "AB900X", + "13859": "AB900X", + "13860": "AB900X", + "13861": "AB900X", + "13862": "AB890X", + "13863": "AB890X", + "13864": "AB890X", + "13865": "AB890X", + "13901": "AB890X", + "13902": "AB890X", + "13903": "AB890X", + "13904": "AB890X", + "13905": "AB890X", + "14001": "AB900X", + "14004": "AB900X", + "14005": "AB900X", + "14006": "AB900X", + "14008": "AB900X", + "14009": "AB900X", + "14010": "AB900X", + "14011": "AB900X", + "14012": "AB900X", + "14013": "AB900X", + "14020": "AB900X", + "14021": "AB900X", + "14024": "AB900X", + "14025": "AB900X", + "14026": "AB900X", + "14027": "AB900X", + "14028": "AB900X", + "14029": "AB900X", + "14030": "AB900X", + "14031": "AB900X", + "14032": "AB900X", + "14033": "AB900X", + "14034": "AB900X", + "14035": "AB900X", + "14036": "AB900X", + "14037": "AB900X", + "14038": "AB900X", + "14039": "AB900X", + "14040": "AB900X", + "14041": "AB900X", + "14042": "AB900X", + "14043": "AB900X", + "14047": "AB900X", + "14048": "AB900X", + "14051": "AB900X", + "14052": "AB900X", + "14054": "AB900X", + "14055": "AB900X", + "14056": "AB900X", + "14057": "AB900X", + "14058": "AB900X", + "14059": "AB900X", + "14060": "AB900X", + "14061": "AB900X", + "14062": "AB900X", + "14063": "AB900X", + "14065": "AB900X", + "14066": "AB900X", + "14067": "AB900X", + "14068": "AB900X", + "14069": "AB900X", + "14070": "AB900X", + "14072": "AB900X", + "14075": "AB900X", + "14080": "AB900X", + "14081": "AB900X", + "14082": "AB900X", + "14083": "AB900X", + "14085": "AB900X", + "14086": "AB900X", + "14091": "AB900X", + "14092": "AB900X", + "14094": "AB900X", + "14095": "AB900X", + "14098": "AB900X", + "14101": "AB900X", + "14102": "AB900X", + "14103": "AB900X", + "14105": "AB900X", + "14107": "AB900X", + "14108": "AB900X", + "14109": "AB900X", + "14110": "AB900X", + "14111": "AB900X", + "14112": "AB900X", + "14113": "AB900X", + "14120": "AB900X", + "14125": "AB900X", + "14126": "AB900X", + "14127": "AB900X", + "14129": "AB900X", + "14130": "AB900X", + "14131": "AB900X", + "14132": "AB900X", + "14133": "AB900X", + "14134": "AB900X", + "14135": "AB900X", + "14136": "AB900X", + "14138": "AB900X", + "14139": "AB900X", + "14140": "AB900X", + "14141": "AB900X", + "14143": "AB900X", + "14144": "AB900X", + "14145": "AB900X", + "14150": "AB900X", + "14151": "AB900X", + "14166": "AB900X", + "14167": "AB900X", + "14168": "AB900X", + "14169": "AB900X", + "14170": "AB900X", + "14171": "AB900X", + "14172": "AB900X", + "14173": "AB900X", + "14174": "AB900X", + "14201": "AB900X", + "14202": "AB900X", + "14203": "AB900X", + "14204": "AB900X", + "14205": "AB900X", + "14206": "AB900X", + "14207": "AB900X", + "14208": "AB900X", + "14209": "AB900X", + "14210": "AB900X", + "14211": "AB900X", + "14212": "AB900X", + "14213": "AB900X", + "14214": "AB900X", + "14215": "AB900X", + "14216": "AB900X", + "14217": "AB900X", + "14218": "AB900X", + "14219": "AB900X", + "14220": "AB900X", + "14221": "AB900X", + "14222": "AB900X", + "14223": "AB900X", + "14224": "AB900X", + "14225": "AB900X", + "14226": "AB900X", + "14227": "AB900X", + "14228": "AB900X", + "14231": "AB900X", + "14233": "AB900X", + "14240": "AB900X", + "14241": "AB900X", + "14260": "AB900X", + "14261": "AB900X", + "14263": "AB900X", + "14264": "AB900X", + "14265": "AB900X", + "14267": "AB900X", + "14269": "AB900X", + "14270": "AB900X", + "14272": "AB900X", + "14273": "AB900X", + "14276": "AB900X", + "14280": "AB900X", + "14301": "AB900X", + "14302": "AB900X", + "14303": "AB900X", + "14304": "AB900X", + "14305": "AB900X", + "14410": "AB900X", + "14411": "AB900X", + "14413": "AB900X", + "14414": "AB900X", + "14415": "AB900X", + "14416": "AB900X", + "14418": "AB900X", + "14420": "AB900X", + "14422": "AB900X", + "14423": "AB900X", + "14424": "AB900X", + "14425": "AB900X", + "14427": "AB900X", + "14428": "AB900X", + "14429": "AB900X", + "14430": "AB900X", + "14432": "AB900X", + "14433": "AB900X", + "14435": "AB900X", + "14437": "AB900X", + "14441": "AB900X", + "14443": "AB900X", + "14445": "AB900X", + "14449": "AB900X", + "14450": "AB900X", + "14452": "AB900X", + "14453": "AB900X", + "14454": "AB900X", + "14456": "AB900X", + "14461": "AB900X", + "14462": "AB900X", + "14463": "AB900X", + "14464": "AB900X", + "14466": "AB900X", + "14467": "AB900X", + "14468": "AB900X", + "14469": "AB900X", + "14470": "AB900X", + "14471": "AB900X", + "14472": "AB900X", + "14475": "AB900X", + "14476": "AB900X", + "14477": "AB900X", + "14478": "AB900X", + "14479": "AB900X", + "14480": "AB900X", + "14481": "AB900X", + "14482": "AB900X", + "14485": "AB900X", + "14486": "AB900X", + "14487": "AB900X", + "14488": "AB900X", + "14489": "AB900X", + "14502": "AB900X", + "14504": "AB900X", + "14505": "AB900X", + "14506": "AB900X", + "14507": "AB900X", + "14508": "AB900X", + "14510": "AB900X", + "14511": "AB900X", + "14512": "AB900X", + "14513": "AB900X", + "14514": "AB900X", + "14515": "AB900X", + "14516": "AB900X", + "14517": "AB900X", + "14518": "AB900X", + "14519": "AB900X", + "14520": "AB900X", + "14521": "AB900X", + "14522": "AB900X", + "14525": "AB900X", + "14526": "AB900X", + "14527": "AB900X", + "14529": "AB890X", + "14530": "AB900X", + "14532": "AB900X", + "14533": "AB900X", + "14534": "AB900X", + "14536": "AB900X", + "14537": "AB900X", + "14538": "AB900X", + "14539": "AB900X", + "14541": "AB900X", + "14542": "AB900X", + "14543": "AB900X", + "14544": "AB900X", + "14545": "AB900X", + "14546": "AB900X", + "14547": "AB900X", + "14548": "AB900X", + "14549": "AB900X", + "14550": "AB900X", + "14551": "AB900X", + "14555": "AB900X", + "14556": "AB900X", + "14557": "AB900X", + "14558": "AB900X", + "14559": "AB900X", + "14560": "AB900X", + "14561": "AB900X", + "14563": "AB900X", + "14564": "AB900X", + "14568": "AB900X", + "14569": "AB900X", + "14571": "AB900X", + "14572": "AB900X", + "14580": "AB900X", + "14585": "AB900X", + "14586": "AB900X", + "14588": "AB900X", + "14589": "AB900X", + "14590": "AB900X", + "14591": "AB900X", + "14592": "AB900X", + "14602": "AB900X", + "14603": "AB900X", + "14604": "AB900X", + "14605": "AB900X", + "14606": "AB900X", + "14607": "AB900X", + "14608": "AB900X", + "14609": "AB900X", + "14610": "AB900X", + "14611": "AB900X", + "14612": "AB900X", + "14613": "AB900X", + "14614": "AB900X", + "14615": "AB900X", + "14616": "AB900X", + "14617": "AB900X", + "14618": "AB900X", + "14619": "AB900X", + "14620": "AB900X", + "14621": "AB900X", + "14622": "AB900X", + "14623": "AB900X", + "14624": "AB900X", + "14625": "AB900X", + "14626": "AB900X", + "14627": "AB900X", + "14638": "AB900X", + "14639": "AB900X", + "14642": "AB900X", + "14643": "AB900X", + "14644": "AB900X", + "14645": "AB900X", + "14646": "AB900X", + "14647": "AB900X", + "14649": "AB900X", + "14650": "AB900X", + "14651": "AB900X", + "14652": "AB900X", + "14653": "AB900X", + "14664": "AB900X", + "14673": "AB900X", + "14683": "AB900X", + "14692": "AB900X", + "14694": "AB900X", + "14701": "AB900X", + "14702": "AB900X", + "14706": "AB900X", + "14707": "AB900X", + "14708": "AB900X", + "14709": "AB900X", + "14710": "AB900X", + "14711": "AB900X", + "14712": "AB900X", + "14714": "AB900X", + "14715": "AB900X", + "14716": "AB900X", + "14717": "AB900X", + "14718": "AB900X", + "14719": "AB900X", + "14720": "AB900X", + "14721": "AB900X", + "14722": "AB900X", + "14723": "AB900X", + "14724": "AB900X", + "14726": "AB900X", + "14727": "AB900X", + "14728": "AB900X", + "14729": "AB900X", + "14730": "AB900X", + "14731": "AB900X", + "14732": "AB900X", + "14733": "AB900X", + "14735": "AB900X", + "14736": "AB900X", + "14737": "AB900X", + "14738": "AB900X", + "14739": "AB900X", + "14740": "AB900X", + "14741": "AB900X", + "14742": "AB900X", + "14743": "AB900X", + "14744": "AB900X", + "14745": "AB900X", + "14747": "AB900X", + "14748": "AB900X", + "14750": "AB900X", + "14751": "AB900X", + "14752": "AB900X", + "14753": "AB900X", + "14754": "AB900X", + "14755": "AB900X", + "14756": "AB900X", + "14757": "AB900X", + "14758": "AB900X", + "14760": "AB900X", + "14762": "AB900X", + "14766": "AB900X", + "14767": "AB900X", + "14769": "AB900X", + "14770": "AB900X", + "14772": "AB900X", + "14774": "AB900X", + "14775": "AB900X", + "14777": "AB900X", + "14778": "AB900X", + "14779": "AB900X", + "14781": "AB900X", + "14782": "AB900X", + "14783": "AB900X", + "14784": "AB900X", + "14785": "AB900X", + "14786": "AB900X", + "14787": "AB900X", + "14788": "AB900X", + "14801": "AB890X", + "14802": "AB900X", + "14803": "AB900X", + "14804": "AB900X", + "14805": "AB890X", + "14806": "AB900X", + "14807": "AB900X", + "14808": "AB900X", + "14809": "AB900X", + "14810": "AB890X", + "14812": "AB890X", + "14813": "AB900X", + "14814": "AB890X", + "14815": "AB890X", + "14816": "AB890X", + "14817": "AB900X", + "14818": "AB890X", + "14819": "AB890X", + "14820": "AB890X", + "14821": "AB890X", + "14822": "AB900X", + "14823": "AB890X", + "14824": "AB890X", + "14825": "AB890X", + "14826": "AB900X", + "14827": "AB890X", + "14830": "AB890X", + "14831": "AB890X", + "14836": "AB900X", + "14837": "AB900X", + "14838": "AB890X", + "14839": "AB890X", + "14840": "AB890X", + "14841": "AB890X", + "14842": "AB900X", + "14843": "AB890X", + "14845": "AB890X", + "14846": "AB900X", + "14847": "AB900X", + "14850": "AB900X", + "14851": "AB900X", + "14852": "AB900X", + "14853": "AB900X", + "14854": "AB900X", + "14855": "AB890X", + "14856": "AB890X", + "14857": "AB900X", + "14858": "AB890X", + "14859": "AB890X", + "14860": "AB900X", + "14861": "AB890X", + "14863": "AB890X", + "14864": "AB890X", + "14865": "AB890X", + "14867": "AB900X", + "14869": "AB890X", + "14870": "AB890X", + "14871": "AB890X", + "14872": "AB890X", + "14873": "AB890X", + "14874": "AB890X", + "14876": "AB890X", + "14877": "AB890X", + "14878": "AB900X", + "14879": "AB890X", + "14880": "AB900X", + "14881": "AB900X", + "14882": "AB900X", + "14883": "AB890X", + "14884": "AB900X", + "14885": "AB890X", + "14886": "AB900X", + "14887": "AB890X", + "14889": "AB890X", + "14891": "AB890X", + "14892": "AB890X", + "14893": "AB890X", + "14894": "AB890X", + "14895": "AB900X", + "14897": "AB900X", + "14898": "AB890X", + "14901": "AB890X", + "14902": "AB890X", + "14903": "AB890X", + "14904": "AB890X", + "14905": "AB890X", + "14925": "AB890X", + "15001": "AB900X", + "15003": "AB900X", + "15004": "AB900X", + "15005": "AB900X", + "15006": "AB900X", + "15007": "AB900X", + "15009": "AB900X", + "15010": "AB900X", + "15012": "AB900X", + "15014": "AB900X", + "15015": "AB900X", + "15017": "AB900X", + "15018": "AB900X", + "15019": "AB900X", + "15020": "AB900X", + "15021": "AB900X", + "15022": "AB900X", + "15024": "AB900X", + "15025": "AB900X", + "15026": "AB900X", + "15027": "AB900X", + "15028": "AB900X", + "15030": "AB900X", + "15031": "AB900X", + "15032": "AB900X", + "15033": "AB900X", + "15034": "AB900X", + "15035": "AB900X", + "15037": "AB900X", + "15038": "AB900X", + "15042": "AB900X", + "15043": "AB900X", + "15044": "AB900X", + "15045": "AB900X", + "15046": "AB900X", + "15047": "AB900X", + "15049": "AB900X", + "15050": "AB900X", + "15051": "AB900X", + "15052": "AB900X", + "15053": "AB900X", + "15054": "AB900X", + "15055": "AB900X", + "15056": "AB900X", + "15057": "AB900X", + "15059": "AB900X", + "15060": "AB900X", + "15061": "AB900X", + "15062": "AB900X", + "15063": "AB900X", + "15064": "AB900X", + "15065": "AB900X", + "15066": "AB900X", + "15067": "AB900X", + "15068": "AB900X", + "15069": "AB900X", + "15071": "AB900X", + "15072": "AB900X", + "15074": "AB900X", + "15075": "AB900X", + "15076": "AB900X", + "15077": "AB900X", + "15078": "AB900X", + "15081": "AB900X", + "15082": "AB900X", + "15083": "AB900X", + "15084": "AB900X", + "15085": "AB900X", + "15086": "AB900X", + "15087": "AB900X", + "15088": "AB900X", + "15089": "AB900X", + "15090": "AB900X", + "15091": "AB900X", + "15095": "AB900X", + "15096": "AB900X", + "15101": "AB900X", + "15102": "AB900X", + "15104": "AB900X", + "15106": "AB900X", + "15108": "AB900X", + "15110": "AB900X", + "15112": "AB900X", + "15116": "AB900X", + "15120": "AB900X", + "15122": "AB900X", + "15123": "AB900X", + "15126": "AB900X", + "15127": "AB900X", + "15129": "AB900X", + "15131": "AB900X", + "15132": "AB900X", + "15133": "AB900X", + "15134": "AB900X", + "15135": "AB900X", + "15136": "AB900X", + "15137": "AB900X", + "15139": "AB900X", + "15140": "AB900X", + "15142": "AB900X", + "15143": "AB900X", + "15144": "AB900X", + "15145": "AB900X", + "15146": "AB900X", + "15147": "AB900X", + "15148": "AB900X", + "15201": "AB900X", + "15202": "AB900X", + "15203": "AB900X", + "15204": "AB900X", + "15205": "AB900X", + "15206": "AB900X", + "15207": "AB900X", + "15208": "AB900X", + "15209": "AB900X", + "15210": "AB900X", + "15211": "AB900X", + "15212": "AB900X", + "15213": "AB900X", + "15214": "AB900X", + "15215": "AB900X", + "15216": "AB900X", + "15217": "AB900X", + "15218": "AB900X", + "15219": "AB900X", + "15220": "AB900X", + "15221": "AB900X", + "15222": "AB900X", + "15223": "AB900X", + "15224": "AB900X", + "15225": "AB900X", + "15226": "AB900X", + "15227": "AB900X", + "15228": "AB900X", + "15229": "AB900X", + "15230": "AB900X", + "15231": "AB900X", + "15232": "AB900X", + "15233": "AB900X", + "15234": "AB900X", + "15235": "AB900X", + "15236": "AB900X", + "15237": "AB900X", + "15238": "AB900X", + "15239": "AB900X", + "15240": "AB900X", + "15241": "AB900X", + "15242": "AB900X", + "15243": "AB900X", + "15244": "AB900X", + "15250": "AB900X", + "15251": "AB900X", + "15252": "AB900X", + "15253": "AB900X", + "15254": "AB900X", + "15255": "AB900X", + "15257": "AB900X", + "15258": "AB900X", + "15259": "AB900X", + "15260": "AB900X", + "15261": "AB900X", + "15262": "AB900X", + "15263": "AB900X", + "15264": "AB900X", + "15265": "AB900X", + "15267": "AB900X", + "15268": "AB900X", + "15270": "AB900X", + "15272": "AB900X", + "15274": "AB900X", + "15275": "AB900X", + "15276": "AB900X", + "15277": "AB900X", + "15278": "AB900X", + "15279": "AB900X", + "15281": "AB900X", + "15282": "AB900X", + "15283": "AB900X", + "15285": "AB900X", + "15286": "AB900X", + "15289": "AB900X", + "15290": "AB900X", + "15295": "AB900X", + "15301": "AB900X", + "15310": "AB900X", + "15311": "AB900X", + "15312": "AB900X", + "15313": "AB900X", + "15314": "AB900X", + "15315": "AB900X", + "15316": "AB900X", + "15317": "AB900X", + "15320": "AB900X", + "15321": "AB900X", + "15322": "AB900X", + "15323": "AB900X", + "15324": "AB900X", + "15325": "AB900X", + "15327": "AB900X", + "15329": "AB900X", + "15330": "AB900X", + "15331": "AB900X", + "15332": "AB900X", + "15333": "AB900X", + "15334": "AB900X", + "15336": "AB900X", + "15337": "AB900X", + "15338": "AB900X", + "15339": "AB900X", + "15340": "AB900X", + "15341": "AB900X", + "15342": "AB900X", + "15344": "AB900X", + "15345": "AB900X", + "15346": "AB900X", + "15347": "AB900X", + "15348": "AB900X", + "15349": "AB900X", + "15350": "AB900X", + "15351": "AB900X", + "15352": "AB900X", + "15353": "AB900X", + "15357": "AB900X", + "15358": "AB900X", + "15359": "AB900X", + "15360": "AB900X", + "15361": "AB900X", + "15362": "AB900X", + "15363": "AB900X", + "15364": "AB900X", + "15365": "AB900X", + "15366": "AB900X", + "15367": "AB900X", + "15368": "AB900X", + "15370": "AB900X", + "15376": "AB900X", + "15377": "AB900X", + "15378": "AB900X", + "15379": "AB900X", + "15380": "AB900X", + "15401": "AB900X", + "15410": "AB900X", + "15411": "AB900X", + "15412": "AB900X", + "15413": "AB900X", + "15415": "AB900X", + "15416": "AB900X", + "15417": "AB900X", + "15419": "AB900X", + "15420": "AB900X", + "15421": "AB900X", + "15422": "AB900X", + "15423": "AB900X", + "15424": "AB900X", + "15425": "AB900X", + "15427": "AB900X", + "15428": "AB900X", + "15429": "AB900X", + "15430": "AB900X", + "15431": "AB900X", + "15432": "AB900X", + "15433": "AB900X", + "15434": "AB900X", + "15435": "AB900X", + "15436": "AB900X", + "15437": "AB900X", + "15438": "AB900X", + "15439": "AB900X", + "15440": "AB900X", + "15442": "AB900X", + "15443": "AB900X", + "15444": "AB900X", + "15445": "AB900X", + "15446": "AB900X", + "15447": "AB900X", + "15448": "AB900X", + "15449": "AB900X", + "15450": "AB900X", + "15451": "AB900X", + "15454": "AB900X", + "15455": "AB900X", + "15456": "AB900X", + "15458": "AB900X", + "15459": "AB900X", + "15460": "AB900X", + "15461": "AB900X", + "15462": "AB900X", + "15463": "AB900X", + "15464": "AB900X", + "15465": "AB900X", + "15466": "AB900X", + "15467": "AB900X", + "15468": "AB900X", + "15469": "AB900X", + "15470": "AB900X", + "15472": "AB900X", + "15473": "AB900X", + "15474": "AB900X", + "15475": "AB900X", + "15476": "AB900X", + "15477": "AB900X", + "15478": "AB900X", + "15479": "AB900X", + "15480": "AB900X", + "15482": "AB900X", + "15483": "AB900X", + "15484": "AB900X", + "15485": "AB900X", + "15486": "AB900X", + "15488": "AB900X", + "15489": "AB900X", + "15490": "AB900X", + "15492": "AB900X", + "15501": "AB900X", + "15502": "AB900X", + "15510": "AB900X", + "15520": "AB900X", + "15521": "AB900X", + "15522": "AB900X", + "15530": "AB900X", + "15531": "AB900X", + "15532": "AB900X", + "15533": "AB900X", + "15534": "AB900X", + "15535": "AB900X", + "15536": "AB892X", + "15537": "AB900X", + "15538": "AB900X", + "15539": "AB900X", + "15540": "AB900X", + "15541": "AB900X", + "15542": "AB900X", + "15544": "AB900X", + "15545": "AB900X", + "15546": "AB900X", + "15547": "AB900X", + "15548": "AB900X", + "15549": "AB900X", + "15550": "AB900X", + "15551": "AB900X", + "15552": "AB900X", + "15553": "AB900X", + "15554": "AB900X", + "15555": "AB900X", + "15557": "AB900X", + "15558": "AB900X", + "15559": "AB900X", + "15560": "AB900X", + "15561": "AB900X", + "15562": "AB900X", + "15563": "AB900X", + "15564": "AB900X", + "15565": "AB900X", + "15601": "AB900X", + "15605": "AB900X", + "15606": "AB900X", + "15610": "AB900X", + "15611": "AB900X", + "15612": "AB900X", + "15613": "AB900X", + "15615": "AB900X", + "15616": "AB900X", + "15617": "AB900X", + "15618": "AB900X", + "15619": "AB900X", + "15620": "AB900X", + "15621": "AB900X", + "15622": "AB900X", + "15623": "AB900X", + "15624": "AB900X", + "15625": "AB900X", + "15626": "AB900X", + "15627": "AB900X", + "15628": "AB900X", + "15629": "AB900X", + "15631": "AB900X", + "15632": "AB900X", + "15633": "AB900X", + "15634": "AB900X", + "15635": "AB900X", + "15636": "AB900X", + "15637": "AB900X", + "15638": "AB900X", + "15639": "AB900X", + "15640": "AB900X", + "15641": "AB900X", + "15642": "AB900X", + "15644": "AB900X", + "15646": "AB900X", + "15647": "AB900X", + "15650": "AB900X", + "15655": "AB900X", + "15656": "AB900X", + "15658": "AB900X", + "15660": "AB900X", + "15661": "AB900X", + "15662": "AB900X", + "15663": "AB900X", + "15664": "AB900X", + "15665": "AB900X", + "15666": "AB900X", + "15668": "AB900X", + "15670": "AB900X", + "15671": "AB900X", + "15672": "AB900X", + "15673": "AB900X", + "15674": "AB900X", + "15675": "AB900X", + "15676": "AB900X", + "15677": "AB900X", + "15678": "AB900X", + "15679": "AB900X", + "15680": "AB900X", + "15681": "AB900X", + "15682": "AB900X", + "15683": "AB900X", + "15684": "AB900X", + "15685": "AB900X", + "15686": "AB900X", + "15687": "AB900X", + "15688": "AB900X", + "15689": "AB900X", + "15690": "AB900X", + "15691": "AB900X", + "15692": "AB900X", + "15693": "AB900X", + "15695": "AB900X", + "15696": "AB900X", + "15697": "AB900X", + "15698": "AB900X", + "15701": "AB900X", + "15705": "AB900X", + "15710": "AB900X", + "15711": "AB900X", + "15712": "AB900X", + "15713": "AB900X", + "15714": "AB900X", + "15715": "AB900X", + "15716": "AB900X", + "15717": "AB900X", + "15720": "AB900X", + "15721": "AB900X", + "15722": "AB900X", + "15723": "AB900X", + "15724": "AB900X", + "15725": "AB900X", + "15727": "AB900X", + "15728": "AB900X", + "15729": "AB900X", + "15730": "AB900X", + "15731": "AB900X", + "15732": "AB900X", + "15733": "AB900X", + "15734": "AB900X", + "15736": "AB900X", + "15737": "AB900X", + "15738": "AB900X", + "15739": "AB900X", + "15740": "AB900X", + "15741": "AB900X", + "15742": "AB900X", + "15744": "AB900X", + "15745": "AB900X", + "15746": "AB900X", + "15747": "AB900X", + "15748": "AB900X", + "15750": "AB900X", + "15752": "AB900X", + "15753": "AB900X", + "15754": "AB900X", + "15756": "AB900X", + "15757": "AB900X", + "15758": "AB900X", + "15759": "AB900X", + "15760": "AB900X", + "15761": "AB900X", + "15762": "AB900X", + "15763": "AB900X", + "15764": "AB900X", + "15765": "AB900X", + "15767": "AB900X", + "15770": "AB900X", + "15771": "AB900X", + "15772": "AB900X", + "15773": "AB900X", + "15774": "AB900X", + "15775": "AB900X", + "15776": "AB900X", + "15777": "AB900X", + "15778": "AB900X", + "15779": "AB900X", + "15780": "AB900X", + "15781": "AB900X", + "15783": "AB900X", + "15784": "AB900X", + "15801": "AB900X", + "15821": "AB900X", + "15822": "AB900X", + "15823": "AB900X", + "15824": "AB900X", + "15825": "AB900X", + "15827": "AB900X", + "15828": "AB900X", + "15829": "AB900X", + "15831": "AB900X", + "15832": "AB900X", + "15834": "AB900X", + "15840": "AB900X", + "15841": "AB900X", + "15845": "AB900X", + "15846": "AB900X", + "15847": "AB900X", + "15848": "AB900X", + "15849": "AB900X", + "15851": "AB900X", + "15853": "AB900X", + "15856": "AB900X", + "15857": "AB900X", + "15860": "AB900X", + "15861": "AB900X", + "15863": "AB900X", + "15864": "AB900X", + "15865": "AB900X", + "15866": "AB900X", + "15868": "AB900X", + "15870": "AB900X", + "15901": "AB900X", + "15902": "AB900X", + "15904": "AB900X", + "15905": "AB900X", + "15906": "AB900X", + "15907": "AB900X", + "15909": "AB900X", + "15915": "AB900X", + "15920": "AB900X", + "15921": "AB900X", + "15922": "AB900X", + "15923": "AB900X", + "15924": "AB900X", + "15925": "AB900X", + "15926": "AB900X", + "15927": "AB900X", + "15928": "AB900X", + "15929": "AB900X", + "15930": "AB900X", + "15931": "AB900X", + "15934": "AB900X", + "15935": "AB900X", + "15936": "AB900X", + "15937": "AB900X", + "15938": "AB900X", + "15940": "AB900X", + "15942": "AB900X", + "15943": "AB900X", + "15944": "AB900X", + "15945": "AB900X", + "15946": "AB900X", + "15948": "AB900X", + "15949": "AB900X", + "15951": "AB900X", + "15952": "AB900X", + "15953": "AB900X", + "15954": "AB900X", + "15955": "AB900X", + "15956": "AB900X", + "15957": "AB900X", + "15958": "AB900X", + "15959": "AB900X", + "15960": "AB900X", + "15961": "AB900X", + "15962": "AB900X", + "15963": "AB900X", + "15989": "AB900X", + "16001": "AB900X", + "16002": "AB900X", + "16003": "AB900X", + "16016": "AB900X", + "16017": "AB900X", + "16018": "AB900X", + "16020": "AB900X", + "16021": "AB900X", + "16022": "AB900X", + "16023": "AB900X", + "16024": "AB900X", + "16025": "AB900X", + "16027": "AB900X", + "16028": "AB900X", + "16029": "AB900X", + "16030": "AB900X", + "16033": "AB900X", + "16034": "AB900X", + "16035": "AB900X", + "16036": "AB900X", + "16037": "AB900X", + "16038": "AB900X", + "16039": "AB900X", + "16040": "AB900X", + "16041": "AB900X", + "16045": "AB900X", + "16046": "AB900X", + "16048": "AB900X", + "16049": "AB900X", + "16050": "AB900X", + "16051": "AB900X", + "16052": "AB900X", + "16053": "AB900X", + "16054": "AB900X", + "16055": "AB900X", + "16056": "AB900X", + "16057": "AB900X", + "16058": "AB900X", + "16059": "AB900X", + "16061": "AB900X", + "16063": "AB900X", + "16066": "AB900X", + "16101": "AB900X", + "16102": "AB900X", + "16103": "AB900X", + "16105": "AB900X", + "16107": "AB900X", + "16108": "AB900X", + "16110": "AB900X", + "16111": "AB900X", + "16112": "AB900X", + "16113": "AB900X", + "16114": "AB900X", + "16115": "AB900X", + "16116": "AB900X", + "16117": "AB900X", + "16120": "AB900X", + "16121": "AB900X", + "16123": "AB900X", + "16124": "AB900X", + "16125": "AB900X", + "16127": "AB900X", + "16130": "AB900X", + "16131": "AB900X", + "16132": "AB900X", + "16133": "AB900X", + "16134": "AB900X", + "16136": "AB900X", + "16137": "AB900X", + "16140": "AB900X", + "16141": "AB900X", + "16142": "AB900X", + "16143": "AB900X", + "16145": "AB900X", + "16146": "AB900X", + "16148": "AB900X", + "16150": "AB900X", + "16151": "AB900X", + "16153": "AB900X", + "16154": "AB900X", + "16155": "AB900X", + "16156": "AB900X", + "16157": "AB900X", + "16159": "AB900X", + "16160": "AB900X", + "16161": "AB900X", + "16172": "AB900X", + "16201": "AB900X", + "16210": "AB900X", + "16211": "AB900X", + "16212": "AB900X", + "16213": "AB900X", + "16214": "AB900X", + "16215": "AB900X", + "16217": "AB900X", + "16218": "AB900X", + "16220": "AB900X", + "16221": "AB900X", + "16222": "AB900X", + "16223": "AB900X", + "16224": "AB900X", + "16225": "AB900X", + "16226": "AB900X", + "16228": "AB900X", + "16229": "AB900X", + "16230": "AB900X", + "16232": "AB900X", + "16233": "AB900X", + "16234": "AB900X", + "16235": "AB900X", + "16236": "AB900X", + "16238": "AB900X", + "16239": "AB900X", + "16240": "AB900X", + "16242": "AB900X", + "16244": "AB900X", + "16245": "AB900X", + "16246": "AB900X", + "16248": "AB900X", + "16249": "AB900X", + "16250": "AB900X", + "16253": "AB900X", + "16254": "AB900X", + "16255": "AB900X", + "16256": "AB900X", + "16257": "AB900X", + "16258": "AB900X", + "16259": "AB900X", + "16260": "AB900X", + "16261": "AB900X", + "16262": "AB900X", + "16263": "AB900X", + "16301": "AB900X", + "16311": "AB900X", + "16312": "AB900X", + "16313": "AB900X", + "16314": "AB900X", + "16316": "AB900X", + "16317": "AB900X", + "16319": "AB900X", + "16321": "AB900X", + "16322": "AB900X", + "16323": "AB900X", + "16326": "AB900X", + "16327": "AB900X", + "16328": "AB900X", + "16329": "AB900X", + "16331": "AB900X", + "16332": "AB900X", + "16333": "AB900X", + "16334": "AB900X", + "16335": "AB900X", + "16340": "AB900X", + "16341": "AB900X", + "16342": "AB900X", + "16343": "AB900X", + "16344": "AB900X", + "16345": "AB900X", + "16346": "AB900X", + "16347": "AB900X", + "16350": "AB900X", + "16351": "AB900X", + "16352": "AB900X", + "16353": "AB900X", + "16354": "AB900X", + "16360": "AB900X", + "16361": "AB900X", + "16362": "AB900X", + "16364": "AB900X", + "16365": "AB900X", + "16366": "AB900X", + "16367": "AB900X", + "16368": "AB900X", + "16369": "AB900X", + "16370": "AB900X", + "16371": "AB900X", + "16372": "AB900X", + "16373": "AB900X", + "16374": "AB900X", + "16375": "AB900X", + "16388": "AB900X", + "16401": "AB900X", + "16402": "AB900X", + "16403": "AB900X", + "16404": "AB900X", + "16405": "AB900X", + "16406": "AB900X", + "16407": "AB900X", + "16410": "AB900X", + "16411": "AB900X", + "16412": "AB900X", + "16413": "AB900X", + "16415": "AB900X", + "16416": "AB900X", + "16417": "AB900X", + "16420": "AB900X", + "16421": "AB900X", + "16422": "AB900X", + "16423": "AB900X", + "16424": "AB900X", + "16426": "AB900X", + "16427": "AB900X", + "16428": "AB900X", + "16430": "AB900X", + "16432": "AB900X", + "16433": "AB900X", + "16434": "AB900X", + "16435": "AB900X", + "16436": "AB900X", + "16438": "AB900X", + "16440": "AB900X", + "16441": "AB900X", + "16442": "AB900X", + "16443": "AB900X", + "16444": "AB900X", + "16475": "AB900X", + "16501": "AB900X", + "16502": "AB900X", + "16503": "AB900X", + "16504": "AB900X", + "16505": "AB900X", + "16506": "AB900X", + "16507": "AB900X", + "16508": "AB900X", + "16509": "AB900X", + "16510": "AB900X", + "16511": "AB900X", + "16512": "AB900X", + "16514": "AB900X", + "16515": "AB900X", + "16522": "AB900X", + "16530": "AB900X", + "16531": "AB900X", + "16532": "AB900X", + "16533": "AB900X", + "16534": "AB900X", + "16538": "AB900X", + "16541": "AB900X", + "16544": "AB900X", + "16546": "AB900X", + "16550": "AB900X", + "16553": "AB900X", + "16554": "AB900X", + "16563": "AB900X", + "16565": "AB900X", + "16601": "AB900X", + "16602": "AB900X", + "16603": "AB900X", + "16611": "AB900X", + "16613": "AB900X", + "16616": "AB900X", + "16617": "AB900X", + "16619": "AB900X", + "16620": "AB900X", + "16621": "AB900X", + "16622": "AB900X", + "16623": "AB900X", + "16624": "AB900X", + "16625": "AB900X", + "16627": "AB900X", + "16629": "AB900X", + "16630": "AB900X", + "16631": "AB900X", + "16633": "AB900X", + "16634": "AB900X", + "16635": "AB900X", + "16636": "AB900X", + "16637": "AB900X", + "16638": "AB900X", + "16639": "AB900X", + "16640": "AB900X", + "16641": "AB900X", + "16644": "AB900X", + "16645": "AB900X", + "16646": "AB900X", + "16647": "AB900X", + "16648": "AB900X", + "16650": "AB900X", + "16651": "AB900X", + "16652": "AB900X", + "16654": "AB900X", + "16655": "AB900X", + "16656": "AB900X", + "16657": "AB900X", + "16659": "AB900X", + "16660": "AB900X", + "16661": "AB900X", + "16662": "AB900X", + "16663": "AB900X", + "16664": "AB900X", + "16665": "AB900X", + "16666": "AB900X", + "16667": "AB900X", + "16668": "AB900X", + "16669": "AB900X", + "16670": "AB900X", + "16671": "AB900X", + "16672": "AB900X", + "16673": "AB900X", + "16674": "AB900X", + "16675": "AB900X", + "16677": "AB900X", + "16678": "AB900X", + "16679": "AB900X", + "16680": "AB900X", + "16681": "AB900X", + "16682": "AB900X", + "16683": "AB900X", + "16684": "AB900X", + "16685": "AB900X", + "16686": "AB900X", + "16689": "AB892X", + "16691": "AB892X", + "16692": "AB900X", + "16693": "AB900X", + "16694": "AB900X", + "16695": "AB900X", + "16698": "AB900X", + "16699": "AB900X", + "16701": "AB900X", + "16720": "AB900X", + "16724": "AB900X", + "16725": "AB900X", + "16726": "AB900X", + "16727": "AB900X", + "16728": "AB900X", + "16729": "AB900X", + "16730": "AB900X", + "16731": "AB900X", + "16732": "AB900X", + "16733": "AB900X", + "16734": "AB900X", + "16735": "AB900X", + "16738": "AB900X", + "16740": "AB900X", + "16743": "AB900X", + "16744": "AB900X", + "16745": "AB900X", + "16746": "AB900X", + "16748": "AB900X", + "16749": "AB900X", + "16750": "AB900X", + "16801": "AB900X", + "16802": "AB900X", + "16803": "AB900X", + "16804": "AB900X", + "16805": "AB900X", + "16820": "AB900X", + "16821": "AB900X", + "16822": "AB890X", + "16823": "AB900X", + "16825": "AB900X", + "16826": "AB890X", + "16827": "AB900X", + "16828": "AB890X", + "16829": "AB900X", + "16830": "AB900X", + "16832": "AB900X", + "16833": "AB900X", + "16834": "AB900X", + "16835": "AB900X", + "16836": "AB900X", + "16837": "AB900X", + "16838": "AB900X", + "16839": "AB900X", + "16840": "AB900X", + "16841": "AB890X", + "16843": "AB900X", + "16844": "AB890X", + "16845": "AB900X", + "16847": "AB900X", + "16848": "AB890X", + "16849": "AB900X", + "16850": "AB900X", + "16851": "AB900X", + "16852": "AB900X", + "16853": "AB890X", + "16854": "AB900X", + "16855": "AB900X", + "16856": "AB900X", + "16858": "AB900X", + "16859": "AB900X", + "16860": "AB900X", + "16861": "AB900X", + "16863": "AB900X", + "16864": "AB900X", + "16865": "AB900X", + "16866": "AB900X", + "16868": "AB900X", + "16870": "AB900X", + "16871": "AB900X", + "16872": "AB890X", + "16873": "AB900X", + "16874": "AB900X", + "16875": "AB900X", + "16876": "AB900X", + "16877": "AB900X", + "16878": "AB900X", + "16879": "AB900X", + "16881": "AB900X", + "16882": "AB900X", + "16901": "AB890X", + "16910": "AB890X", + "16911": "AB890X", + "16912": "AB890X", + "16914": "AB890X", + "16915": "AB900X", + "16917": "AB890X", + "16918": "AB890X", + "16920": "AB890X", + "16921": "AB890X", + "16922": "AB900X", + "16923": "AB900X", + "16925": "AB890X", + "16926": "AB890X", + "16927": "AB890X", + "16928": "AB890X", + "16929": "AB890X", + "16930": "AB890X", + "16932": "AB890X", + "16933": "AB890X", + "16935": "AB890X", + "16936": "AB890X", + "16937": "AB900X", + "16938": "AB890X", + "16939": "AB890X", + "16940": "AB890X", + "16941": "AB900X", + "16942": "AB890X", + "16943": "AB890X", + "16945": "AB890X", + "16946": "AB890X", + "16947": "AB890X", + "16948": "AB890X", + "16950": "AB890X", + "17001": "AB892X", + "17002": "AB892X", + "17003": "AB892X", + "17004": "AB892X", + "17005": "AB892X", + "17006": "AB892X", + "17007": "AB892X", + "17008": "AB892X", + "17009": "AB892X", + "17010": "AB892X", + "17011": "AB892X", + "17012": "AB892X", + "17013": "AB892X", + "17014": "AB892X", + "17015": "AB892X", + "17016": "AB892X", + "17017": "AB892X", + "17018": "AB892X", + "17019": "AB892X", + "17020": "AB892X", + "17021": "AB892X", + "17022": "AB892X", + "17023": "AB892X", + "17024": "AB892X", + "17025": "AB892X", + "17026": "AB892X", + "17027": "AB892X", + "17028": "AB892X", + "17029": "AB892X", + "17030": "AB892X", + "17032": "AB892X", + "17033": "AB892X", + "17034": "AB892X", + "17035": "AB892X", + "17036": "AB892X", + "17037": "AB892X", + "17038": "AB892X", + "17039": "AB892X", + "17040": "AB892X", + "17041": "AB892X", + "17042": "AB892X", + "17043": "AB892X", + "17044": "AB892X", + "17045": "AB890X", + "17046": "AB892X", + "17047": "AB892X", + "17048": "AB892X", + "17049": "AB892X", + "17050": "AB892X", + "17051": "AB892X", + "17052": "AB900X", + "17053": "AB892X", + "17054": "AB892X", + "17055": "AB892X", + "17056": "AB892X", + "17057": "AB892X", + "17058": "AB892X", + "17059": "AB892X", + "17060": "AB900X", + "17061": "AB892X", + "17062": "AB892X", + "17063": "AB892X", + "17064": "AB892X", + "17065": "AB892X", + "17066": "AB892X", + "17067": "AB892X", + "17068": "AB892X", + "17069": "AB892X", + "17070": "AB892X", + "17071": "AB892X", + "17072": "AB892X", + "17073": "AB892X", + "17074": "AB892X", + "17075": "AB892X", + "17076": "AB892X", + "17077": "AB892X", + "17078": "AB892X", + "17080": "AB892X", + "17081": "AB892X", + "17082": "AB892X", + "17083": "AB892X", + "17084": "AB892X", + "17085": "AB892X", + "17086": "AB892X", + "17087": "AB892X", + "17088": "AB892X", + "17089": "AB892X", + "17090": "AB892X", + "17091": "AB892X", + "17093": "AB892X", + "17094": "AB892X", + "17097": "AB892X", + "17098": "AB892X", + "17099": "AB892X", + "17101": "AB892X", + "17102": "AB892X", + "17103": "AB892X", + "17104": "AB892X", + "17105": "AB892X", + "17106": "AB892X", + "17107": "AB892X", + "17108": "AB892X", + "17109": "AB892X", + "17110": "AB892X", + "17111": "AB892X", + "17112": "AB892X", + "17113": "AB892X", + "17120": "AB892X", + "17121": "AB892X", + "17122": "AB892X", + "17123": "AB892X", + "17124": "AB892X", + "17125": "AB892X", + "17126": "AB892X", + "17127": "AB892X", + "17128": "AB892X", + "17129": "AB892X", + "17130": "AB892X", + "17140": "AB892X", + "17177": "AB892X", + "17201": "AB892X", + "17202": "AB892X", + "17210": "AB892X", + "17211": "AB900X", + "17212": "AB892X", + "17213": "AB900X", + "17214": "AB892X", + "17215": "AB892X", + "17217": "AB892X", + "17219": "AB892X", + "17220": "AB892X", + "17221": "AB892X", + "17222": "AB892X", + "17223": "AB892X", + "17224": "AB892X", + "17225": "AB892X", + "17228": "AB892X", + "17229": "AB892X", + "17231": "AB892X", + "17232": "AB892X", + "17233": "AB892X", + "17235": "AB892X", + "17236": "AB892X", + "17237": "AB892X", + "17238": "AB892X", + "17239": "AB900X", + "17240": "AB892X", + "17241": "AB892X", + "17243": "AB900X", + "17244": "AB892X", + "17246": "AB892X", + "17247": "AB892X", + "17249": "AB900X", + "17250": "AB892X", + "17251": "AB892X", + "17252": "AB892X", + "17253": "AB900X", + "17254": "AB892X", + "17255": "AB900X", + "17256": "AB892X", + "17257": "AB892X", + "17260": "AB900X", + "17261": "AB892X", + "17262": "AB892X", + "17263": "AB892X", + "17264": "AB900X", + "17265": "AB892X", + "17266": "AB892X", + "17267": "AB892X", + "17268": "AB892X", + "17270": "AB892X", + "17271": "AB892X", + "17272": "AB892X", + "17301": "AB892X", + "17302": "AB892X", + "17303": "AB892X", + "17304": "AB892X", + "17306": "AB892X", + "17307": "AB892X", + "17309": "AB892X", + "17310": "AB892X", + "17311": "AB892X", + "17312": "AB892X", + "17313": "AB892X", + "17314": "AB892X", + "17315": "AB892X", + "17316": "AB892X", + "17317": "AB892X", + "17318": "AB892X", + "17319": "AB892X", + "17320": "AB892X", + "17321": "AB892X", + "17322": "AB892X", + "17323": "AB892X", + "17324": "AB892X", + "17325": "AB892X", + "17326": "AB892X", + "17327": "AB892X", + "17329": "AB892X", + "17331": "AB892X", + "17332": "AB892X", + "17333": "AB892X", + "17334": "AB892X", + "17337": "AB892X", + "17339": "AB892X", + "17340": "AB892X", + "17342": "AB892X", + "17343": "AB892X", + "17344": "AB892X", + "17345": "AB892X", + "17347": "AB892X", + "17349": "AB892X", + "17350": "AB892X", + "17352": "AB892X", + "17353": "AB892X", + "17354": "AB892X", + "17355": "AB892X", + "17356": "AB892X", + "17358": "AB892X", + "17360": "AB892X", + "17361": "AB892X", + "17362": "AB892X", + "17363": "AB892X", + "17364": "AB892X", + "17365": "AB892X", + "17366": "AB892X", + "17368": "AB892X", + "17370": "AB892X", + "17371": "AB892X", + "17372": "AB892X", + "17375": "AB892X", + "17401": "AB892X", + "17402": "AB892X", + "17403": "AB892X", + "17404": "AB892X", + "17405": "AB892X", + "17406": "AB892X", + "17407": "AB892X", + "17408": "AB892X", + "17415": "AB892X", + "17501": "AB892X", + "17502": "AB892X", + "17503": "AB892X", + "17504": "AB892X", + "17505": "AB892X", + "17506": "AB892X", + "17507": "AB892X", + "17508": "AB892X", + "17509": "AB892X", + "17512": "AB892X", + "17516": "AB892X", + "17517": "AB892X", + "17518": "AB892X", + "17519": "AB892X", + "17520": "AB892X", + "17521": "AB892X", + "17522": "AB892X", + "17527": "AB892X", + "17528": "AB892X", + "17529": "AB892X", + "17532": "AB892X", + "17533": "AB892X", + "17534": "AB892X", + "17535": "AB892X", + "17536": "AB892X", + "17537": "AB892X", + "17538": "AB892X", + "17540": "AB892X", + "17543": "AB892X", + "17545": "AB892X", + "17547": "AB892X", + "17549": "AB892X", + "17550": "AB892X", + "17551": "AB892X", + "17552": "AB892X", + "17554": "AB892X", + "17555": "AB892X", + "17557": "AB892X", + "17560": "AB892X", + "17562": "AB892X", + "17563": "AB892X", + "17564": "AB892X", + "17565": "AB892X", + "17566": "AB892X", + "17567": "AB892X", + "17568": "AB892X", + "17569": "AB892X", + "17570": "AB892X", + "17572": "AB892X", + "17573": "AB892X", + "17575": "AB892X", + "17576": "AB892X", + "17578": "AB892X", + "17579": "AB892X", + "17580": "AB892X", + "17581": "AB892X", + "17582": "AB892X", + "17583": "AB892X", + "17584": "AB892X", + "17585": "AB892X", + "17601": "AB892X", + "17602": "AB892X", + "17603": "AB892X", + "17604": "AB892X", + "17605": "AB892X", + "17606": "AB892X", + "17607": "AB892X", + "17608": "AB892X", + "17611": "AB892X", + "17699": "AB892X", + "17701": "AB890X", + "17702": "AB890X", + "17703": "AB890X", + "17705": "AB890X", + "17720": "AB890X", + "17721": "AB890X", + "17723": "AB890X", + "17724": "AB890X", + "17726": "AB890X", + "17727": "AB890X", + "17728": "AB890X", + "17729": "AB900X", + "17730": "AB890X", + "17731": "AB890X", + "17735": "AB890X", + "17737": "AB890X", + "17738": "AB890X", + "17739": "AB890X", + "17740": "AB890X", + "17742": "AB890X", + "17744": "AB890X", + "17745": "AB890X", + "17747": "AB890X", + "17748": "AB890X", + "17749": "AB890X", + "17750": "AB890X", + "17751": "AB890X", + "17752": "AB890X", + "17754": "AB890X", + "17756": "AB890X", + "17758": "AB890X", + "17760": "AB890X", + "17762": "AB890X", + "17763": "AB890X", + "17764": "AB890X", + "17765": "AB890X", + "17767": "AB890X", + "17768": "AB890X", + "17769": "AB890X", + "17771": "AB890X", + "17772": "AB890X", + "17773": "AB890X", + "17774": "AB890X", + "17776": "AB890X", + "17777": "AB890X", + "17778": "AB890X", + "17779": "AB890X", + "17801": "AB890X", + "17810": "AB890X", + "17812": "AB892X", + "17813": "AB890X", + "17814": "AB890X", + "17815": "AB890X", + "17820": "AB890X", + "17821": "AB890X", + "17822": "AB890X", + "17823": "AB892X", + "17824": "AB890X", + "17827": "AB890X", + "17829": "AB890X", + "17830": "AB892X", + "17831": "AB890X", + "17832": "AB890X", + "17833": "AB890X", + "17834": "AB890X", + "17835": "AB890X", + "17836": "AB890X", + "17837": "AB890X", + "17839": "AB890X", + "17840": "AB890X", + "17841": "AB892X", + "17842": "AB890X", + "17843": "AB890X", + "17844": "AB890X", + "17845": "AB890X", + "17846": "AB890X", + "17847": "AB890X", + "17850": "AB890X", + "17851": "AB890X", + "17853": "AB890X", + "17855": "AB890X", + "17856": "AB890X", + "17857": "AB890X", + "17858": "AB890X", + "17859": "AB890X", + "17860": "AB890X", + "17861": "AB890X", + "17862": "AB890X", + "17864": "AB890X", + "17865": "AB890X", + "17866": "AB890X", + "17867": "AB890X", + "17868": "AB890X", + "17870": "AB890X", + "17872": "AB890X", + "17876": "AB890X", + "17877": "AB890X", + "17878": "AB890X", + "17880": "AB890X", + "17881": "AB890X", + "17882": "AB890X", + "17883": "AB890X", + "17884": "AB890X", + "17885": "AB890X", + "17886": "AB890X", + "17887": "AB890X", + "17888": "AB890X", + "17889": "AB890X", + "17901": "AB890X", + "17920": "AB890X", + "17921": "AB890X", + "17922": "AB890X", + "17923": "AB890X", + "17925": "AB890X", + "17929": "AB890X", + "17930": "AB890X", + "17931": "AB890X", + "17932": "AB890X", + "17933": "AB890X", + "17934": "AB890X", + "17935": "AB890X", + "17936": "AB890X", + "17938": "AB892X", + "17941": "AB892X", + "17942": "AB890X", + "17943": "AB890X", + "17944": "AB890X", + "17945": "AB890X", + "17946": "AB890X", + "17948": "AB890X", + "17949": "AB890X", + "17951": "AB890X", + "17952": "AB890X", + "17953": "AB890X", + "17954": "AB890X", + "17957": "AB892X", + "17959": "AB890X", + "17960": "AB890X", + "17961": "AB890X", + "17963": "AB890X", + "17964": "AB890X", + "17965": "AB890X", + "17966": "AB890X", + "17967": "AB890X", + "17968": "AB892X", + "17970": "AB890X", + "17972": "AB890X", + "17974": "AB890X", + "17976": "AB890X", + "17978": "AB892X", + "17979": "AB890X", + "17980": "AB892X", + "17981": "AB890X", + "17982": "AB890X", + "17983": "AB892X", + "17985": "AB890X", + "18001": "AB890X", + "18002": "AB890X", + "18003": "AB890X", + "18010": "AB890X", + "18011": "AB890X", + "18012": "AB890X", + "18013": "AB890X", + "18014": "AB890X", + "18015": "AB890X", + "18016": "AB890X", + "18017": "AB890X", + "18018": "AB890X", + "18020": "AB890X", + "18025": "AB890X", + "18030": "AB890X", + "18031": "AB890X", + "18032": "AB890X", + "18034": "AB890X", + "18035": "AB890X", + "18036": "AB890X", + "18037": "AB890X", + "18038": "AB890X", + "18039": "AB890X", + "18040": "AB890X", + "18041": "AB890X", + "18042": "AB890X", + "18043": "AB890X", + "18044": "AB890X", + "18045": "AB890X", + "18046": "AB890X", + "18049": "AB890X", + "18050": "AB890X", + "18051": "AB890X", + "18052": "AB890X", + "18053": "AB890X", + "18054": "AB890X", + "18055": "AB890X", + "18056": "AB890X", + "18058": "AB890X", + "18059": "AB890X", + "18060": "AB890X", + "18062": "AB890X", + "18063": "AB890X", + "18064": "AB890X", + "18065": "AB890X", + "18066": "AB890X", + "18067": "AB890X", + "18068": "AB890X", + "18069": "AB890X", + "18070": "AB890X", + "18071": "AB890X", + "18072": "AB890X", + "18073": "AB890X", + "18074": "AB890X", + "18076": "AB890X", + "18077": "AB890X", + "18078": "AB890X", + "18079": "AB890X", + "18080": "AB890X", + "18081": "AB890X", + "18083": "AB890X", + "18084": "AB890X", + "18085": "AB890X", + "18086": "AB890X", + "18087": "AB890X", + "18088": "AB890X", + "18091": "AB890X", + "18092": "AB890X", + "18098": "AB890X", + "18099": "AB890X", + "18101": "AB890X", + "18102": "AB890X", + "18103": "AB890X", + "18104": "AB890X", + "18105": "AB890X", + "18106": "AB890X", + "18109": "AB890X", + "18175": "AB890X", + "18195": "AB890X", + "18201": "AB890X", + "18202": "AB890X", + "18210": "AB890X", + "18211": "AB890X", + "18212": "AB890X", + "18214": "AB890X", + "18216": "AB890X", + "18218": "AB890X", + "18219": "AB890X", + "18220": "AB890X", + "18221": "AB890X", + "18222": "AB890X", + "18223": "AB890X", + "18224": "AB890X", + "18225": "AB890X", + "18229": "AB890X", + "18230": "AB890X", + "18231": "AB890X", + "18232": "AB890X", + "18234": "AB890X", + "18235": "AB890X", + "18237": "AB890X", + "18239": "AB890X", + "18240": "AB890X", + "18241": "AB890X", + "18242": "AB890X", + "18244": "AB890X", + "18245": "AB890X", + "18246": "AB890X", + "18247": "AB890X", + "18248": "AB890X", + "18249": "AB890X", + "18250": "AB890X", + "18251": "AB890X", + "18252": "AB890X", + "18254": "AB890X", + "18255": "AB890X", + "18256": "AB890X", + "18301": "AB890X", + "18302": "AB890X", + "18320": "AB890X", + "18321": "AB890X", + "18322": "AB890X", + "18323": "AB890X", + "18324": "AB890X", + "18325": "AB890X", + "18326": "AB890X", + "18327": "AB890X", + "18328": "AB890X", + "18330": "AB890X", + "18331": "AB890X", + "18332": "AB890X", + "18333": "AB890X", + "18334": "AB890X", + "18335": "AB890X", + "18336": "AB890X", + "18337": "AB890X", + "18340": "AB890X", + "18341": "AB890X", + "18342": "AB890X", + "18343": "AB890X", + "18344": "AB890X", + "18346": "AB890X", + "18347": "AB890X", + "18348": "AB890X", + "18349": "AB890X", + "18350": "AB890X", + "18351": "AB890X", + "18352": "AB890X", + "18353": "AB890X", + "18354": "AB890X", + "18355": "AB890X", + "18356": "AB890X", + "18357": "AB890X", + "18360": "AB890X", + "18370": "AB890X", + "18371": "AB890X", + "18372": "AB890X", + "18373": "AB890X", + "18403": "AB890X", + "18405": "AB890X", + "18407": "AB890X", + "18410": "AB890X", + "18411": "AB890X", + "18413": "AB890X", + "18414": "AB890X", + "18415": "AB890X", + "18416": "AB890X", + "18417": "AB890X", + "18419": "AB890X", + "18420": "AB890X", + "18421": "AB890X", + "18424": "AB890X", + "18425": "AB890X", + "18426": "AB890X", + "18427": "AB890X", + "18428": "AB890X", + "18430": "AB890X", + "18431": "AB890X", + "18433": "AB890X", + "18434": "AB890X", + "18435": "AB890X", + "18436": "AB890X", + "18437": "AB890X", + "18438": "AB890X", + "18439": "AB890X", + "18440": "AB890X", + "18441": "AB890X", + "18443": "AB890X", + "18444": "AB890X", + "18445": "AB890X", + "18446": "AB890X", + "18447": "AB890X", + "18448": "AB890X", + "18449": "AB890X", + "18451": "AB890X", + "18452": "AB890X", + "18453": "AB890X", + "18454": "AB890X", + "18455": "AB890X", + "18456": "AB890X", + "18457": "AB890X", + "18458": "AB890X", + "18459": "AB890X", + "18460": "AB890X", + "18461": "AB890X", + "18462": "AB890X", + "18463": "AB890X", + "18464": "AB890X", + "18465": "AB890X", + "18466": "AB890X", + "18469": "AB890X", + "18470": "AB890X", + "18471": "AB890X", + "18472": "AB890X", + "18473": "AB890X", + "18501": "AB890X", + "18502": "AB890X", + "18503": "AB890X", + "18504": "AB890X", + "18505": "AB890X", + "18507": "AB890X", + "18508": "AB890X", + "18509": "AB890X", + "18510": "AB890X", + "18512": "AB890X", + "18514": "AB890X", + "18515": "AB890X", + "18517": "AB890X", + "18518": "AB890X", + "18519": "AB890X", + "18522": "AB890X", + "18540": "AB890X", + "18577": "AB890X", + "18601": "AB890X", + "18602": "AB890X", + "18603": "AB890X", + "18610": "AB890X", + "18611": "AB890X", + "18612": "AB890X", + "18614": "AB890X", + "18615": "AB890X", + "18616": "AB890X", + "18617": "AB890X", + "18618": "AB890X", + "18619": "AB890X", + "18621": "AB890X", + "18622": "AB890X", + "18623": "AB890X", + "18624": "AB890X", + "18625": "AB890X", + "18626": "AB890X", + "18627": "AB890X", + "18628": "AB890X", + "18629": "AB890X", + "18630": "AB890X", + "18631": "AB890X", + "18632": "AB890X", + "18634": "AB890X", + "18635": "AB890X", + "18636": "AB890X", + "18640": "AB890X", + "18641": "AB890X", + "18642": "AB890X", + "18643": "AB890X", + "18644": "AB890X", + "18651": "AB890X", + "18653": "AB890X", + "18654": "AB890X", + "18655": "AB890X", + "18656": "AB890X", + "18657": "AB890X", + "18660": "AB890X", + "18661": "AB890X", + "18690": "AB890X", + "18701": "AB890X", + "18702": "AB890X", + "18703": "AB890X", + "18704": "AB890X", + "18705": "AB890X", + "18706": "AB890X", + "18707": "AB890X", + "18708": "AB890X", + "18709": "AB890X", + "18710": "AB890X", + "18711": "AB890X", + "18762": "AB890X", + "18764": "AB890X", + "18765": "AB890X", + "18766": "AB890X", + "18767": "AB890X", + "18769": "AB890X", + "18773": "AB890X", + "18801": "AB890X", + "18810": "AB890X", + "18812": "AB890X", + "18813": "AB890X", + "18814": "AB890X", + "18815": "AB890X", + "18816": "AB890X", + "18817": "AB890X", + "18818": "AB890X", + "18820": "AB890X", + "18821": "AB890X", + "18822": "AB890X", + "18823": "AB890X", + "18824": "AB890X", + "18825": "AB890X", + "18826": "AB890X", + "18827": "AB890X", + "18828": "AB890X", + "18829": "AB890X", + "18830": "AB890X", + "18831": "AB890X", + "18832": "AB890X", + "18833": "AB890X", + "18834": "AB890X", + "18837": "AB890X", + "18840": "AB890X", + "18842": "AB890X", + "18843": "AB890X", + "18844": "AB890X", + "18845": "AB890X", + "18846": "AB890X", + "18847": "AB890X", + "18848": "AB890X", + "18850": "AB890X", + "18851": "AB890X", + "18853": "AB890X", + "18854": "AB890X", + "18901": "AB890X", + "18902": "AB890X", + "18910": "AB890X", + "18911": "AB890X", + "18912": "AB890X", + "18913": "AB890X", + "18914": "AB890X", + "18915": "AB890X", + "18916": "AB890X", + "18917": "AB890X", + "18918": "AB890X", + "18920": "AB890X", + "18921": "AB890X", + "18922": "AB890X", + "18923": "AB890X", + "18924": "AB890X", + "18925": "AB890X", + "18926": "AB890X", + "18927": "AB890X", + "18928": "AB890X", + "18929": "AB890X", + "18930": "AB890X", + "18931": "AB890X", + "18932": "AB890X", + "18933": "AB890X", + "18934": "AB890X", + "18935": "AB890X", + "18936": "AB890X", + "18938": "AB890X", + "18940": "AB890X", + "18942": "AB890X", + "18943": "AB890X", + "18944": "AB890X", + "18946": "AB890X", + "18947": "AB890X", + "18949": "AB890X", + "18950": "AB890X", + "18951": "AB890X", + "18953": "AB890X", + "18954": "AB890X", + "18955": "AB890X", + "18956": "AB890X", + "18957": "AB890X", + "18958": "AB890X", + "18960": "AB890X", + "18962": "AB890X", + "18963": "AB890X", + "18964": "AB890X", + "18966": "AB890X", + "18968": "AB890X", + "18969": "AB890X", + "18970": "AB890X", + "18971": "AB890X", + "18972": "AB890X", + "18974": "AB890X", + "18976": "AB890X", + "18977": "AB890X", + "18979": "AB890X", + "18980": "AB890X", + "18981": "AB890X", + "18991": "AB890X", + "19001": "AB890X", + "19002": "AB890X", + "19003": "AB890X", + "19004": "AB890X", + "19006": "AB890X", + "19007": "AB890X", + "19008": "AB890X", + "19009": "AB890X", + "19010": "AB890X", + "19012": "AB890X", + "19013": "AB890X", + "19014": "AB890X", + "19015": "AB890X", + "19016": "AB890X", + "19017": "AB890X", + "19018": "AB890X", + "19019": "AB890X", + "19020": "AB890X", + "19021": "AB890X", + "19022": "AB890X", + "19023": "AB890X", + "19025": "AB890X", + "19026": "AB890X", + "19027": "AB890X", + "19028": "AB890X", + "19029": "AB890X", + "19030": "AB890X", + "19031": "AB890X", + "19032": "AB890X", + "19033": "AB890X", + "19034": "AB890X", + "19035": "AB890X", + "19036": "AB890X", + "19037": "AB890X", + "19038": "AB890X", + "19039": "AB890X", + "19040": "AB890X", + "19041": "AB890X", + "19043": "AB890X", + "19044": "AB890X", + "19046": "AB890X", + "19047": "AB890X", + "19048": "AB890X", + "19049": "AB890X", + "19050": "AB890X", + "19052": "AB890X", + "19053": "AB890X", + "19054": "AB890X", + "19055": "AB890X", + "19056": "AB890X", + "19057": "AB890X", + "19058": "AB890X", + "19061": "AB890X", + "19063": "AB890X", + "19064": "AB890X", + "19065": "AB890X", + "19066": "AB890X", + "19067": "AB890X", + "19070": "AB890X", + "19072": "AB890X", + "19073": "AB890X", + "19074": "AB890X", + "19075": "AB890X", + "19076": "AB890X", + "19078": "AB890X", + "19079": "AB890X", + "19080": "AB890X", + "19081": "AB890X", + "19082": "AB890X", + "19083": "AB890X", + "19085": "AB890X", + "19086": "AB890X", + "19087": "AB890X", + "19088": "AB890X", + "19089": "AB890X", + "19090": "AB890X", + "19091": "AB890X", + "19092": "AB890X", + "19093": "AB890X", + "19094": "AB890X", + "19095": "AB890X", + "19096": "AB890X", + "19098": "AB890X", + "19099": "AB890X", + "19101": "AB890X", + "19102": "AB890X", + "19103": "AB890X", + "19104": "AB890X", + "19105": "AB890X", + "19106": "AB890X", + "19107": "AB890X", + "19108": "AB890X", + "19109": "AB890X", + "19110": "AB890X", + "19111": "AB890X", + "19112": "AB890X", + "19113": "AB890X", + "19114": "AB890X", + "19115": "AB890X", + "19116": "AB890X", + "19118": "AB890X", + "19119": "AB890X", + "19120": "AB890X", + "19121": "AB890X", + "19122": "AB890X", + "19123": "AB890X", + "19124": "AB890X", + "19125": "AB890X", + "19126": "AB890X", + "19127": "AB890X", + "19128": "AB890X", + "19129": "AB890X", + "19130": "AB890X", + "19131": "AB890X", + "19132": "AB890X", + "19133": "AB890X", + "19134": "AB890X", + "19135": "AB890X", + "19136": "AB890X", + "19137": "AB890X", + "19138": "AB890X", + "19139": "AB890X", + "19140": "AB890X", + "19141": "AB890X", + "19142": "AB890X", + "19143": "AB890X", + "19144": "AB890X", + "19145": "AB890X", + "19146": "AB890X", + "19147": "AB890X", + "19148": "AB890X", + "19149": "AB890X", + "19150": "AB890X", + "19151": "AB890X", + "19152": "AB890X", + "19153": "AB890X", + "19154": "AB890X", + "19155": "AB890X", + "19160": "AB890X", + "19161": "AB890X", + "19162": "AB890X", + "19170": "AB890X", + "19171": "AB890X", + "19172": "AB890X", + "19173": "AB890X", + "19175": "AB890X", + "19176": "AB890X", + "19177": "AB890X", + "19178": "AB890X", + "19179": "AB890X", + "19181": "AB890X", + "19182": "AB890X", + "19183": "AB890X", + "19184": "AB890X", + "19185": "AB890X", + "19187": "AB890X", + "19188": "AB890X", + "19191": "AB890X", + "19192": "AB890X", + "19193": "AB890X", + "19194": "AB890X", + "19195": "AB890X", + "19196": "AB890X", + "19197": "AB890X", + "19244": "AB890X", + "19255": "AB890X", + "19301": "AB890X", + "19310": "AB890X", + "19311": "AB890X", + "19312": "AB890X", + "19316": "AB890X", + "19317": "AB890X", + "19318": "AB890X", + "19319": "AB890X", + "19320": "AB890X", + "19330": "AB890X", + "19331": "AB890X", + "19333": "AB890X", + "19335": "AB890X", + "19339": "AB890X", + "19340": "AB890X", + "19341": "AB890X", + "19342": "AB890X", + "19343": "AB890X", + "19344": "AB890X", + "19345": "AB890X", + "19346": "AB890X", + "19347": "AB890X", + "19348": "AB890X", + "19350": "AB890X", + "19351": "AB890X", + "19352": "AB890X", + "19353": "AB890X", + "19354": "AB890X", + "19355": "AB890X", + "19357": "AB890X", + "19358": "AB890X", + "19360": "AB890X", + "19362": "AB890X", + "19363": "AB890X", + "19365": "AB890X", + "19366": "AB890X", + "19367": "AB890X", + "19369": "AB890X", + "19371": "AB890X", + "19372": "AB890X", + "19373": "AB890X", + "19374": "AB890X", + "19375": "AB890X", + "19376": "AB890X", + "19380": "AB890X", + "19381": "AB890X", + "19382": "AB890X", + "19383": "AB890X", + "19390": "AB890X", + "19395": "AB890X", + "19397": "AB890X", + "19398": "AB890X", + "19399": "AB890X", + "19401": "AB890X", + "19403": "AB890X", + "19404": "AB890X", + "19405": "AB890X", + "19406": "AB890X", + "19407": "AB890X", + "19408": "AB890X", + "19409": "AB890X", + "19415": "AB890X", + "19420": "AB890X", + "19421": "AB890X", + "19422": "AB890X", + "19423": "AB890X", + "19424": "AB890X", + "19425": "AB890X", + "19426": "AB890X", + "19428": "AB890X", + "19429": "AB890X", + "19430": "AB890X", + "19432": "AB890X", + "19435": "AB890X", + "19436": "AB890X", + "19437": "AB890X", + "19438": "AB890X", + "19440": "AB890X", + "19441": "AB890X", + "19442": "AB890X", + "19443": "AB890X", + "19444": "AB890X", + "19446": "AB890X", + "19450": "AB890X", + "19451": "AB890X", + "19453": "AB890X", + "19454": "AB890X", + "19455": "AB890X", + "19456": "AB890X", + "19457": "AB890X", + "19460": "AB890X", + "19462": "AB890X", + "19464": "AB890X", + "19465": "AB887X", + "19468": "AB890X", + "19470": "AB890X", + "19472": "AB890X", + "19473": "AB890X", + "19474": "AB890X", + "19475": "AB890X", + "19477": "AB890X", + "19478": "AB890X", + "19479": "AB891X", + "19480": "AB890X", + "19481": "AB890X", + "19482": "AB890X", + "19483": "AB890X", + "19484": "AB890X", + "19485": "AB890X", + "19486": "AB890X", + "19487": "AB890X", + "19488": "AB890X", + "19489": "AB890X", + "19490": "AB890X", + "19492": "AB890X", + "19493": "AB890X", + "19494": "AB890X", + "19495": "AB890X", + "19496": "AB890X", + "19501": "AB892X", + "19503": "AB890X", + "19504": "AB890X", + "19505": "AB890X", + "19506": "AB890X", + "19507": "AB890X", + "19508": "AB890X", + "19510": "AB890X", + "19511": "AB890X", + "19512": "AB890X", + "19516": "AB890X", + "19518": "AB890X", + "19519": "AB890X", + "19520": "AB890X", + "19522": "AB890X", + "19523": "AB890X", + "19525": "AB890X", + "19526": "AB890X", + "19529": "AB890X", + "19530": "AB890X", + "19533": "AB890X", + "19534": "AB890X", + "19535": "AB890X", + "19536": "AB890X", + "19538": "AB890X", + "19539": "AB890X", + "19540": "AB890X", + "19541": "AB890X", + "19542": "AB890X", + "19543": "AB890X", + "19544": "AB890X", + "19545": "AB890X", + "19547": "AB890X", + "19548": "AB890X", + "19549": "AB890X", + "19550": "AB890X", + "19551": "AB890X", + "19554": "AB890X", + "19555": "AB890X", + "19559": "AB890X", + "19560": "AB890X", + "19562": "AB890X", + "19564": "AB890X", + "19565": "AB890X", + "19567": "AB890X", + "19601": "AB890X", + "19602": "AB890X", + "19603": "AB892X", + "19604": "AB890X", + "19605": "AB890X", + "19606": "AB890X", + "19607": "AB890X", + "19608": "AB890X", + "19609": "AB890X", + "19610": "AB890X", + "19611": "AB890X", + "19612": "AB890X", + "19640": "AB890X", + "19701": "AB890X", + "19702": "AB890X", + "19703": "AB890X", + "19706": "AB890X", + "19707": "AB890X", + "19708": "AB890X", + "19709": "AB890X", + "19710": "AB890X", + "19711": "AB890X", + "19712": "AB890X", + "19713": "AB890X", + "19714": "AB890X", + "19715": "AB890X", + "19716": "AB890X", + "19717": "AB890X", + "19718": "AB890X", + "19720": "AB890X", + "19721": "AB890X", + "19725": "AB890X", + "19726": "AB890X", + "19730": "AB890X", + "19731": "AB890X", + "19732": "AB890X", + "19733": "AB890X", + "19734": "AB890X", + "19735": "AB890X", + "19736": "AB890X", + "19801": "AB890X", + "19802": "AB890X", + "19803": "AB890X", + "19804": "AB890X", + "19805": "AB890X", + "19806": "AB890X", + "19807": "AB890X", + "19808": "AB890X", + "19809": "AB890X", + "19810": "AB890X", + "19850": "AB890X", + "19880": "AB890X", + "19884": "AB890X", + "19885": "AB890X", + "19886": "AB890X", + "19887": "AB890X", + "19889": "AB890X", + "19890": "AB890X", + "19891": "AB890X", + "19892": "AB890X", + "19893": "AB890X", + "19894": "AB890X", + "19895": "AB890X", + "19896": "AB890X", + "19897": "AB890X", + "19898": "AB890X", + "19899": "AB890X", + "19901": "AB890X", + "19902": "AB890X", + "19903": "AB890X", + "19904": "AB890X", + "19905": "AB890X", + "19906": "AB890X", + "19930": "AB890X", + "19931": "AB890X", + "19933": "AB890X", + "19934": "AB890X", + "19936": "AB890X", + "19938": "AB890X", + "19939": "AB890X", + "19940": "AB890X", + "19941": "AB890X", + "19943": "AB890X", + "19944": "AB890X", + "19945": "AB890X", + "19946": "AB890X", + "19947": "AB890X", + "19950": "AB890X", + "19951": "AB890X", + "19952": "AB890X", + "19953": "AB890X", + "19954": "AB890X", + "19955": "AB890X", + "19956": "AB890X", + "19958": "AB890X", + "19960": "AB890X", + "19961": "AB890X", + "19962": "AB890X", + "19963": "AB890X", + "19964": "AB890X", + "19966": "AB890X", + "19967": "AB890X", + "19968": "AB890X", + "19969": "AB890X", + "19970": "AB890X", + "19971": "AB890X", + "19973": "AB890X", + "19975": "AB890X", + "19977": "AB890X", + "19979": "AB890X", + "19980": "AB890X", + "20001": "AB892X", + "20002": "AB892X", + "20008": "AB892X", + "20011": "AB892X", + "20100": "AB890X", + "20101": "AB892X", + "20102": "AB892X", + "20103": "AB892X", + "20104": "AB892X", + "20105": "AB892X", + "20106": "AB892X", + "20107": "AB892X", + "20108": "AB892X", + "20109": "AB892X", + "20110": "AB892X", + "20111": "AB892X", + "20112": "AB892X", + "20113": "AB892X", + "20115": "AB892X", + "20116": "AB892X", + "20117": "AB892X", + "20118": "AB892X", + "20119": "AB892X", + "20120": "AB892X", + "20121": "AB892X", + "20122": "AB892X", + "20124": "AB892X", + "20128": "AB892X", + "20129": "AB892X", + "20130": "AB892X", + "20131": "AB892X", + "20132": "AB892X", + "20134": "AB892X", + "20135": "AB892X", + "20136": "AB892X", + "20137": "AB892X", + "20138": "AB892X", + "20139": "AB892X", + "20140": "AB892X", + "20141": "AB892X", + "20142": "AB892X", + "20143": "AB892X", + "20144": "AB892X", + "20146": "AB892X", + "20147": "AB892X", + "20148": "AB892X", + "20149": "AB892X", + "20151": "AB892X", + "20152": "AB892X", + "20153": "AB892X", + "20155": "AB892X", + "20156": "AB892X", + "20158": "AB892X", + "20159": "AB892X", + "20160": "AB892X", + "20163": "AB892X", + "20164": "AB892X", + "20165": "AB892X", + "20166": "AB892X", + "20167": "AB892X", + "20168": "AB892X", + "20169": "AB892X", + "20170": "AB892X", + "20171": "AB892X", + "20172": "AB892X", + "20175": "AB892X", + "20176": "AB892X", + "20177": "AB892X", + "20178": "AB892X", + "20180": "AB892X", + "20181": "AB892X", + "20182": "AB892X", + "20184": "AB892X", + "20185": "AB892X", + "20186": "AB892X", + "20187": "AB892X", + "20188": "AB892X", + "20189": "AB892X", + "20190": "AB892X", + "20191": "AB892X", + "20192": "AB892X", + "20193": "AB892X", + "20194": "AB892X", + "20195": "AB892X", + "20196": "AB892X", + "20197": "AB892X", + "20198": "AB892X", + "20199": "AB892X", + "20559": "AB892X", + "20601": "AB892X", + "20602": "AB892X", + "20603": "AB892X", + "20604": "AB892X", + "20606": "AB892X", + "20607": "AB892X", + "20608": "AB892X", + "20609": "AB892X", + "20610": "AB892X", + "20611": "AB892X", + "20612": "AB892X", + "20613": "AB892X", + "20615": "AB892X", + "20616": "AB892X", + "20617": "AB892X", + "20618": "AB892X", + "20619": "AB892X", + "20620": "AB892X", + "20621": "AB892X", + "20622": "AB892X", + "20623": "AB892X", + "20624": "AB892X", + "20625": "AB892X", + "20626": "AB892X", + "20627": "AB892X", + "20628": "AB892X", + "20629": "AB892X", + "20630": "AB892X", + "20632": "AB892X", + "20634": "AB892X", + "20635": "AB892X", + "20636": "AB892X", + "20637": "AB892X", + "20639": "AB892X", + "20640": "AB892X", + "20643": "AB892X", + "20645": "AB892X", + "20646": "AB892X", + "20650": "AB892X", + "20653": "AB892X", + "20656": "AB892X", + "20657": "AB892X", + "20658": "AB892X", + "20659": "AB892X", + "20660": "AB892X", + "20661": "AB892X", + "20662": "AB892X", + "20664": "AB892X", + "20667": "AB892X", + "20670": "AB892X", + "20674": "AB892X", + "20675": "AB892X", + "20676": "AB892X", + "20677": "AB892X", + "20678": "AB892X", + "20680": "AB892X", + "20682": "AB892X", + "20684": "AB892X", + "20685": "AB892X", + "20686": "AB892X", + "20687": "AB892X", + "20688": "AB892X", + "20689": "AB892X", + "20690": "AB892X", + "20692": "AB892X", + "20693": "AB892X", + "20695": "AB892X", + "20697": "AB892X", + "20701": "AB890X", + "20703": "AB892X", + "20704": "AB892X", + "20705": "AB892X", + "20706": "AB892X", + "20707": "AB892X", + "20708": "AB892X", + "20709": "AB892X", + "20710": "AB892X", + "20711": "AB890X", + "20712": "AB892X", + "20714": "AB892X", + "20715": "AB892X", + "20716": "AB892X", + "20717": "AB892X", + "20718": "AB892X", + "20719": "AB892X", + "20720": "AB892X", + "20721": "AB892X", + "20722": "AB892X", + "20723": "AB890X", + "20724": "AB890X", + "20725": "AB892X", + "20726": "AB892X", + "20731": "AB892X", + "20732": "AB892X", + "20733": "AB890X", + "20735": "AB892X", + "20736": "AB892X", + "20737": "AB892X", + "20738": "AB892X", + "20740": "AB892X", + "20741": "AB892X", + "20742": "AB892X", + "20743": "AB892X", + "20744": "AB892X", + "20745": "AB892X", + "20746": "AB892X", + "20747": "AB892X", + "20748": "AB892X", + "20749": "AB892X", + "20750": "AB892X", + "20751": "AB890X", + "20752": "AB892X", + "20753": "AB892X", + "20754": "AB892X", + "20755": "AB890X", + "20757": "AB892X", + "20758": "AB890X", + "20759": "AB890X", + "20762": "AB892X", + "20763": "AB890X", + "20764": "AB890X", + "20765": "AB890X", + "20768": "AB892X", + "20769": "AB892X", + "20770": "AB892X", + "20771": "AB892X", + "20772": "AB892X", + "20773": "AB892X", + "20774": "AB892X", + "20775": "AB892X", + "20776": "AB890X", + "20777": "AB890X", + "20778": "AB890X", + "20779": "AB890X", + "20781": "AB892X", + "20782": "AB892X", + "20783": "AB892X", + "20784": "AB892X", + "20785": "AB892X", + "20787": "AB892X", + "20788": "AB892X", + "20790": "AB892X", + "20791": "AB892X", + "20792": "AB892X", + "20794": "AB890X", + "20797": "AB892X", + "20799": "AB892X", + "20810": "AB892X", + "20811": "AB892X", + "20812": "AB892X", + "20813": "AB892X", + "20814": "AB892X", + "20815": "AB892X", + "20816": "AB892X", + "20817": "AB892X", + "20818": "AB892X", + "20824": "AB892X", + "20825": "AB892X", + "20827": "AB892X", + "20830": "AB892X", + "20832": "AB892X", + "20833": "AB892X", + "20837": "AB892X", + "20838": "AB892X", + "20839": "AB892X", + "20841": "AB892X", + "20842": "AB892X", + "20847": "AB892X", + "20848": "AB892X", + "20849": "AB892X", + "20850": "AB892X", + "20851": "AB892X", + "20852": "AB892X", + "20853": "AB892X", + "20854": "AB892X", + "20855": "AB892X", + "20857": "AB892X", + "20859": "AB892X", + "20860": "AB892X", + "20861": "AB892X", + "20862": "AB892X", + "20866": "AB892X", + "20868": "AB892X", + "20871": "AB892X", + "20872": "AB892X", + "20874": "AB892X", + "20875": "AB892X", + "20876": "AB892X", + "20877": "AB892X", + "20878": "AB892X", + "20879": "AB892X", + "20880": "AB892X", + "20882": "AB892X", + "20883": "AB892X", + "20884": "AB892X", + "20885": "AB892X", + "20886": "AB892X", + "20889": "AB892X", + "20891": "AB892X", + "20892": "AB892X", + "20894": "AB892X", + "20895": "AB892X", + "20896": "AB892X", + "20897": "AB892X", + "20898": "AB892X", + "20899": "AB892X", + "20901": "AB892X", + "20902": "AB892X", + "20903": "AB892X", + "20904": "AB892X", + "20905": "AB892X", + "20906": "AB892X", + "20907": "AB892X", + "20908": "AB892X", + "20910": "AB892X", + "20911": "AB892X", + "20912": "AB892X", + "20913": "AB892X", + "20914": "AB892X", + "20915": "AB892X", + "20916": "AB892X", + "20918": "AB892X", + "20993": "AB892X", + "20997": "AB892X", + "21001": "AB890X", + "21005": "AB890X", + "21009": "AB890X", + "21010": "AB890X", + "21012": "AB890X", + "21013": "AB890X", + "21014": "AB890X", + "21015": "AB890X", + "21017": "AB890X", + "21018": "AB890X", + "21020": "AB890X", + "21022": "AB890X", + "21023": "AB890X", + "21027": "AB890X", + "21028": "AB890X", + "21029": "AB890X", + "21030": "AB890X", + "21031": "AB890X", + "21032": "AB890X", + "21034": "AB890X", + "21035": "AB890X", + "21036": "AB890X", + "21037": "AB890X", + "21040": "AB890X", + "21041": "AB890X", + "21042": "AB890X", + "21043": "AB890X", + "21044": "AB890X", + "21045": "AB890X", + "21046": "AB890X", + "21047": "AB890X", + "21048": "AB890X", + "21050": "AB890X", + "21051": "AB890X", + "21052": "AB890X", + "21053": "AB890X", + "21054": "AB890X", + "21056": "AB890X", + "21057": "AB890X", + "21060": "AB890X", + "21061": "AB890X", + "21062": "AB890X", + "21065": "AB890X", + "21071": "AB890X", + "21074": "AB890X", + "21075": "AB890X", + "21076": "AB890X", + "21077": "AB890X", + "21078": "AB890X", + "21082": "AB890X", + "21084": "AB890X", + "21085": "AB890X", + "21087": "AB890X", + "21088": "AB890X", + "21090": "AB890X", + "21092": "AB890X", + "21093": "AB890X", + "21094": "AB890X", + "21098": "AB890X", + "21102": "AB890X", + "21104": "AB890X", + "21105": "AB890X", + "21106": "AB890X", + "21108": "AB890X", + "21111": "AB890X", + "21113": "AB890X", + "21114": "AB890X", + "21117": "AB890X", + "21120": "AB890X", + "21122": "AB890X", + "21123": "AB890X", + "21128": "AB890X", + "21130": "AB890X", + "21131": "AB890X", + "21132": "AB890X", + "21133": "AB890X", + "21136": "AB890X", + "21139": "AB890X", + "21140": "AB890X", + "21144": "AB890X", + "21146": "AB890X", + "21150": "AB890X", + "21152": "AB890X", + "21153": "AB890X", + "21154": "AB890X", + "21155": "AB890X", + "21156": "AB890X", + "21157": "AB890X", + "21158": "AB890X", + "21160": "AB890X", + "21161": "AB890X", + "21162": "AB890X", + "21163": "AB890X", + "21200": "AB890X", + "21201": "AB890X", + "21202": "AB890X", + "21203": "AB890X", + "21204": "AB890X", + "21205": "AB890X", + "21206": "AB890X", + "21207": "AB890X", + "21208": "AB890X", + "21209": "AB890X", + "21210": "AB890X", + "21211": "AB890X", + "21212": "AB890X", + "21213": "AB890X", + "21214": "AB890X", + "21215": "AB890X", + "21216": "AB890X", + "21217": "AB890X", + "21218": "AB890X", + "21219": "AB890X", + "21220": "AB890X", + "21221": "AB890X", + "21222": "AB890X", + "21223": "AB890X", + "21224": "AB890X", + "21225": "AB890X", + "21226": "AB890X", + "21227": "AB890X", + "21228": "AB890X", + "21229": "AB890X", + "21230": "AB890X", + "21231": "AB890X", + "21233": "AB890X", + } +) diff --git a/profiling/dict_huge.py b/profiling/dict_huge.py new file mode 100644 index 0000000..11c7fe1 --- /dev/null +++ b/profiling/dict_huge.py @@ -0,0 +1,41440 @@ +config = some.Structure( + some_mapping={ + "00501": "AB890X", + "00544": "AB890X", + "01001": "AB889X", + "01002": "AB889X", + "01003": "AB889X", + "01004": "AB889X", + "01005": "AB889X", + "01007": "AB889X", + "01008": "AB889X", + "01009": "AB889X", + "01010": "AB889X", + "01011": "AB889X", + "01012": "AB889X", + "01013": "AB889X", + "01014": "AB889X", + "01020": "AB889X", + "01021": "AB889X", + "01022": "AB889X", + "01026": "AB889X", + "01027": "AB889X", + "01028": "AB889X", + "01029": "AB889X", + "01030": "AB889X", + "01031": "AB889X", + "01032": "AB889X", + "01033": "AB889X", + "01034": "AB889X", + "01035": "AB889X", + "01036": "AB889X", + "01037": "AB889X", + "01038": "AB889X", + "01039": "AB889X", + "01040": "AB889X", + "01041": "AB889X", + "01050": "AB889X", + "01053": "AB889X", + "01054": "AB889X", + "01056": "AB889X", + "01057": "AB889X", + "01059": "AB889X", + "01060": "AB889X", + "01061": "AB889X", + "01062": "AB889X", + "01063": "AB889X", + "01066": "AB889X", + "01068": "AB889X", + "01069": "AB889X", + "01070": "AB889X", + "01071": "AB889X", + "01072": "AB889X", + "01073": "AB889X", + "01074": "AB889X", + "01075": "AB889X", + "01077": "AB889X", + "01079": "AB889X", + "01080": "AB889X", + "01081": "AB889X", + "01082": "AB889X", + "01083": "AB889X", + "01084": "AB889X", + "01085": "AB889X", + "01086": "AB889X", + "01088": "AB889X", + "01089": "AB889X", + "01090": "AB889X", + "01092": "AB889X", + "01093": "AB889X", + "01094": "AB889X", + "01095": "AB889X", + "01096": "AB889X", + "01097": "AB889X", + "01098": "AB889X", + "01101": "AB889X", + "01102": "AB889X", + "01103": "AB889X", + "01104": "AB889X", + "01105": "AB889X", + "01106": "AB889X", + "01107": "AB889X", + "01108": "AB889X", + "01109": "AB889X", + "01111": "AB889X", + "01115": "AB889X", + "01116": "AB889X", + "01118": "AB889X", + "01119": "AB889X", + "01128": "AB889X", + "01129": "AB889X", + "01133": "AB889X", + "01138": "AB889X", + "01139": "AB889X", + "01144": "AB889X", + "01151": "AB889X", + "01152": "AB889X", + "01195": "AB889X", + "01199": "AB889X", + "01201": "AB890X", + "01202": "AB889X", + "01203": "AB889X", + "01220": "AB890X", + "01222": "AB889X", + "01223": "AB889X", + "01224": "AB889X", + "01225": "AB889X", + "01226": "AB889X", + "01227": "AB889X", + "01229": "AB889X", + "01230": "AB889X", + "01235": "AB889X", + "01236": "AB889X", + "01237": "AB889X", + "01238": "AB889X", + "01240": "AB889X", + "01242": "AB889X", + "01243": "AB889X", + "01244": "AB889X", + "01245": "AB889X", + "01247": "AB890X", + "01252": "AB889X", + "01253": "AB889X", + "01254": "AB889X", + "01255": "AB889X", + "01256": "AB889X", + "01257": "AB890X", + "01258": "AB889X", + "01259": "AB889X", + "01260": "AB889X", + "01262": "AB889X", + "01263": "AB889X", + "01264": "AB889X", + "01266": "AB889X", + "01267": "AB890X", + "01270": "AB889X", + "01301": "AB889X", + "01302": "AB889X", + "01330": "AB889X", + "01331": "AB889X", + "01337": "AB889X", + "01338": "AB889X", + "01339": "AB889X", + "01340": "AB889X", + "01341": "AB889X", + "01342": "AB889X", + "01343": "AB889X", + "01344": "AB889X", + "01346": "AB889X", + "01347": "AB889X", + "01349": "AB889X", + "01350": "AB889X", + "01351": "AB889X", + "01354": "AB889X", + "01355": "AB889X", + "01360": "AB889X", + "01364": "AB889X", + "01366": "AB889X", + "01367": "AB890X", + "01368": "AB889X", + "01370": "AB889X", + "01373": "AB889X", + "01375": "AB889X", + "01376": "AB889X", + "01378": "AB889X", + "01379": "AB889X", + "01380": "AB889X", + "01420": "AB889X", + "01430": "AB889X", + "01431": "AB889X", + "01432": "AB889X", + "01434": "AB889X", + "01436": "AB889X", + "01438": "AB889X", + "01440": "AB889X", + "01441": "AB889X", + "01450": "AB889X", + "01451": "AB889X", + "01452": "AB889X", + "01453": "AB889X", + "01460": "AB889X", + "01462": "AB889X", + "01463": "AB889X", + "01464": "AB889X", + "01467": "AB889X", + "01468": "AB889X", + "01469": "AB889X", + "01470": "AB889X", + "01471": "AB889X", + "01472": "AB889X", + "01473": "AB889X", + "01474": "AB889X", + "01475": "AB889X", + "01477": "AB889X", + "01501": "AB889X", + "01503": "AB889X", + "01504": "AB889X", + "01505": "AB889X", + "01506": "AB889X", + "01507": "AB889X", + "01508": "AB889X", + "01509": "AB889X", + "01510": "AB889X", + "01515": "AB889X", + "01516": "AB889X", + "01517": "AB889X", + "01518": "AB889X", + "01519": "AB889X", + "01520": "AB889X", + "01521": "AB889X", + "01522": "AB889X", + "01523": "AB889X", + "01524": "AB889X", + "01525": "AB889X", + "01526": "AB889X", + "01527": "AB889X", + "01529": "AB889X", + "01531": "AB889X", + "01532": "AB889X", + "01534": "AB889X", + "01535": "AB889X", + "01536": "AB889X", + "01537": "AB889X", + "01538": "AB889X", + "01540": "AB889X", + "01541": "AB889X", + "01542": "AB889X", + "01543": "AB889X", + "01545": "AB889X", + "01546": "AB889X", + "01550": "AB889X", + "01560": "AB889X", + "01561": "AB889X", + "01562": "AB889X", + "01564": "AB889X", + "01566": "AB889X", + "01568": "AB889X", + "01569": "AB889X", + "01570": "AB889X", + "01571": "AB889X", + "01580": "AB889X", + "01581": "AB889X", + "01582": "AB889X", + "01583": "AB889X", + "01585": "AB889X", + "01586": "AB889X", + "01588": "AB889X", + "01590": "AB889X", + "01601": "AB889X", + "01602": "AB889X", + "01603": "AB889X", + "01604": "AB889X", + "01605": "AB889X", + "01606": "AB889X", + "01607": "AB889X", + "01608": "AB889X", + "01609": "AB889X", + "01610": "AB889X", + "01611": "AB889X", + "01612": "AB889X", + "01613": "AB889X", + "01614": "AB889X", + "01615": "AB889X", + "01653": "AB889X", + "01654": "AB889X", + "01655": "AB889X", + "01701": "AB889X", + "01702": "AB889X", + "01703": "AB889X", + "01704": "AB889X", + "01705": "AB889X", + "01718": "AB889X", + "01719": "AB889X", + "01720": "AB889X", + "01721": "AB889X", + "01730": "AB889X", + "01731": "AB889X", + "01740": "AB889X", + "01741": "AB889X", + "01742": "AB889X", + "01745": "AB889X", + "01746": "AB889X", + "01747": "AB889X", + "01748": "AB889X", + "01749": "AB889X", + "01752": "AB889X", + "01754": "AB889X", + "01756": "AB889X", + "01757": "AB889X", + "01760": "AB889X", + "01770": "AB889X", + "01772": "AB889X", + "01773": "AB889X", + "01775": "AB889X", + "01776": "AB889X", + "01778": "AB889X", + "01784": "AB889X", + "01801": "AB889X", + "01803": "AB889X", + "01805": "AB889X", + "01806": "AB889X", + "01807": "AB889X", + "01808": "AB889X", + "01810": "AB889X", + "01812": "AB889X", + "01813": "AB889X", + "01815": "AB889X", + "01821": "AB889X", + "01822": "AB889X", + "01824": "AB889X", + "01826": "AB889X", + "01827": "AB889X", + "01830": "AB889X", + "01831": "AB889X", + "01832": "AB889X", + "01833": "AB889X", + "01834": "AB889X", + "01835": "AB889X", + "01840": "AB889X", + "01841": "AB889X", + "01842": "AB889X", + "01843": "AB889X", + "01844": "AB889X", + "01845": "AB889X", + "01850": "AB889X", + "01851": "AB889X", + "01852": "AB889X", + "01853": "AB889X", + "01854": "AB889X", + "01860": "AB889X", + "01862": "AB889X", + "01863": "AB889X", + "01864": "AB889X", + "01865": "AB889X", + "01866": "AB889X", + "01867": "AB889X", + "01876": "AB889X", + "01879": "AB889X", + "01880": "AB889X", + "01885": "AB889X", + "01886": "AB889X", + "01887": "AB889X", + "01888": "AB889X", + "01889": "AB889X", + "01890": "AB889X", + "01899": "AB889X", + "01901": "AB889X", + "01902": "AB889X", + "01903": "AB889X", + "01904": "AB889X", + "01905": "AB889X", + "01906": "AB889X", + "01907": "AB889X", + "01908": "AB889X", + "01910": "AB889X", + "01913": "AB889X", + "01915": "AB889X", + "01921": "AB889X", + "01922": "AB889X", + "01923": "AB889X", + "01929": "AB889X", + "01930": "AB889X", + "01931": "AB889X", + "01936": "AB889X", + "01937": "AB889X", + "01938": "AB889X", + "01940": "AB889X", + "01944": "AB889X", + "01945": "AB889X", + "01949": "AB889X", + "01950": "AB889X", + "01951": "AB889X", + "01952": "AB889X", + "01960": "AB889X", + "01961": "AB889X", + "01965": "AB889X", + "01966": "AB889X", + "01969": "AB889X", + "01970": "AB889X", + "01971": "AB889X", + "01982": "AB889X", + "01983": "AB889X", + "01984": "AB889X", + "01985": "AB889X", + "02018": "AB889X", + "02019": "AB889X", + "02020": "AB889X", + "02021": "AB889X", + "02025": "AB889X", + "02026": "AB889X", + "02027": "AB889X", + "02030": "AB889X", + "02031": "AB889X", + "02032": "AB889X", + "02035": "AB889X", + "02038": "AB889X", + "02040": "AB889X", + "02041": "AB889X", + "02043": "AB889X", + "02044": "AB889X", + "02045": "AB889X", + "02047": "AB889X", + "02048": "AB889X", + "02050": "AB889X", + "02051": "AB889X", + "02052": "AB889X", + "02053": "AB889X", + "02054": "AB889X", + "02055": "AB889X", + "02056": "AB889X", + "02059": "AB889X", + "02060": "AB889X", + "02061": "AB889X", + "02062": "AB889X", + "02065": "AB889X", + "02066": "AB889X", + "02067": "AB889X", + "02070": "AB889X", + "02071": "AB889X", + "02072": "AB889X", + "02081": "AB889X", + "02090": "AB889X", + "02093": "AB889X", + "02108": "AB889X", + "02109": "AB889X", + "02110": "AB889X", + "02111": "AB889X", + "02112": "AB889X", + "02113": "AB889X", + "02114": "AB889X", + "02115": "AB889X", + "02116": "AB889X", + "02117": "AB889X", + "02118": "AB889X", + "02119": "AB889X", + "02120": "AB889X", + "02121": "AB889X", + "02122": "AB889X", + "02123": "AB889X", + "02124": "AB889X", + "02125": "AB889X", + "02126": "AB889X", + "02127": "AB889X", + "02128": "AB889X", + "02129": "AB889X", + "02130": "AB889X", + "02131": "AB889X", + "02132": "AB889X", + "02133": "AB889X", + "02134": "AB889X", + "02135": "AB889X", + "02136": "AB889X", + "02137": "AB889X", + "02138": "AB889X", + "02139": "AB889X", + "02140": "AB889X", + "02141": "AB889X", + "02142": "AB889X", + "02143": "AB889X", + "02144": "AB889X", + "02145": "AB889X", + "02148": "AB889X", + "02149": "AB889X", + "02150": "AB889X", + "02151": "AB889X", + "02152": "AB889X", + "02153": "AB889X", + "02155": "AB889X", + "02156": "AB889X", + "02163": "AB889X", + "02169": "AB889X", + "02170": "AB889X", + "02171": "AB889X", + "02176": "AB889X", + "02180": "AB889X", + "02184": "AB889X", + "02185": "AB889X", + "02186": "AB889X", + "02187": "AB889X", + "02188": "AB889X", + "02189": "AB889X", + "02190": "AB889X", + "02191": "AB889X", + "02196": "AB889X", + "02199": "AB889X", + "02201": "AB889X", + "02203": "AB889X", + "02204": "AB889X", + "02205": "AB889X", + "02206": "AB889X", + "02207": "AB889X", + "02210": "AB889X", + "02211": "AB889X", + "02212": "AB889X", + "02215": "AB889X", + "02216": "AB889X", + "02217": "AB889X", + "02222": "AB889X", + "02228": "AB889X", + "02238": "AB889X", + "02239": "AB889X", + "02241": "AB889X", + "02266": "AB889X", + "02269": "AB889X", + "02283": "AB889X", + "02284": "AB889X", + "02293": "AB889X", + "02295": "AB889X", + "02297": "AB889X", + "02298": "AB889X", + "02301": "AB889X", + "02302": "AB889X", + "02303": "AB889X", + "02304": "AB889X", + "02305": "AB889X", + "02322": "AB889X", + "02324": "AB889X", + "02325": "AB889X", + "02327": "AB889X", + "02330": "AB889X", + "02331": "AB889X", + "02332": "AB889X", + "02333": "AB889X", + "02334": "AB889X", + "02337": "AB889X", + "02338": "AB889X", + "02339": "AB889X", + "02340": "AB889X", + "02341": "AB889X", + "02343": "AB889X", + "02344": "AB889X", + "02345": "AB889X", + "02346": "AB889X", + "02347": "AB889X", + "02348": "AB889X", + "02349": "AB889X", + "02350": "AB889X", + "02351": "AB889X", + "02355": "AB889X", + "02356": "AB889X", + "02357": "AB889X", + "02358": "AB889X", + "02359": "AB889X", + "02360": "AB889X", + "02361": "AB889X", + "02362": "AB889X", + "02364": "AB889X", + "02366": "AB889X", + "02367": "AB889X", + "02368": "AB889X", + "02370": "AB889X", + "02375": "AB889X", + "02379": "AB889X", + "02381": "AB889X", + "02382": "AB889X", + "02420": "AB889X", + "02421": "AB889X", + "02445": "AB889X", + "02446": "AB889X", + "02447": "AB889X", + "02451": "AB889X", + "02452": "AB889X", + "02453": "AB889X", + "02454": "AB889X", + "02455": "AB889X", + "02456": "AB889X", + "02457": "AB889X", + "02458": "AB890X", + "02459": "AB889X", + "02460": "AB889X", + "02461": "AB889X", + "02462": "AB889X", + "02464": "AB889X", + "02465": "AB889X", + "02466": "AB889X", + "02467": "AB889X", + "02468": "AB889X", + "02471": "AB889X", + "02472": "AB889X", + "02474": "AB889X", + "02475": "AB889X", + "02476": "AB889X", + "02477": "AB889X", + "02478": "AB889X", + "02479": "AB889X", + "02481": "AB889X", + "02482": "AB889X", + "02492": "AB889X", + "02493": "AB889X", + "02494": "AB889X", + "02495": "AB889X", + "02532": "AB889X", + "02534": "AB889X", + "02535": "AB889X", + "02536": "AB889X", + "02537": "AB889X", + "02538": "AB889X", + "02539": "AB889X", + "02540": "AB889X", + "02541": "AB889X", + "02542": "AB889X", + "02543": "AB889X", + "02552": "AB889X", + "02553": "AB889X", + "02554": "AB889X", + "02556": "AB889X", + "02557": "AB889X", + "02558": "AB889X", + "02559": "AB889X", + "02561": "AB889X", + "02562": "AB889X", + "02563": "AB889X", + "02564": "AB889X", + "02565": "AB889X", + "02568": "AB889X", + "02571": "AB889X", + "02573": "AB889X", + "02574": "AB889X", + "02575": "AB889X", + "02576": "AB889X", + "02584": "AB889X", + "02601": "AB889X", + "02630": "AB889X", + "02631": "AB889X", + "02632": "AB889X", + "02633": "AB889X", + "02634": "AB889X", + "02635": "AB889X", + "02636": "AB889X", + "02637": "AB889X", + "02638": "AB889X", + "02639": "AB889X", + "02641": "AB889X", + "02642": "AB889X", + "02643": "AB889X", + "02644": "AB889X", + "02645": "AB889X", + "02646": "AB889X", + "02647": "AB889X", + "02648": "AB889X", + "02649": "AB889X", + "02650": "AB889X", + "02651": "AB889X", + "02652": "AB889X", + "02653": "AB889X", + "02655": "AB889X", + "02657": "AB889X", + "02659": "AB889X", + "02660": "AB889X", + "02661": "AB889X", + "02662": "AB889X", + "02663": "AB889X", + "02664": "AB889X", + "02666": "AB889X", + "02667": "AB889X", + "02668": "AB889X", + "02669": "AB889X", + "02670": "AB889X", + "02671": "AB889X", + "02672": "AB889X", + "02673": "AB889X", + "02675": "AB889X", + "02702": "AB889X", + "02703": "AB889X", + "02712": "AB889X", + "02713": "AB889X", + "02714": "AB889X", + "02715": "AB889X", + "02717": "AB889X", + "02718": "AB889X", + "02719": "AB889X", + "02720": "AB889X", + "02721": "AB889X", + "02722": "AB889X", + "02723": "AB889X", + "02724": "AB889X", + "02725": "AB889X", + "02726": "AB889X", + "02738": "AB889X", + "02739": "AB889X", + "02740": "AB889X", + "02741": "AB889X", + "02742": "AB889X", + "02743": "AB889X", + "02744": "AB889X", + "02745": "AB889X", + "02746": "AB889X", + "02747": "AB889X", + "02748": "AB889X", + "02760": "AB889X", + "02761": "AB889X", + "02762": "AB889X", + "02763": "AB889X", + "02764": "AB889X", + "02766": "AB889X", + "02767": "AB889X", + "02768": "AB889X", + "02769": "AB889X", + "02770": "AB889X", + "02771": "AB889X", + "02777": "AB889X", + "02779": "AB889X", + "02780": "AB889X", + "02783": "AB889X", + "02790": "AB889X", + "02791": "AB889X", + "02801": "AB889X", + "02802": "AB889X", + "02804": "AB889X", + "02806": "AB889X", + "02807": "AB889X", + "02808": "AB889X", + "02809": "AB889X", + "02812": "AB889X", + "02813": "AB889X", + "02814": "AB889X", + "02815": "AB889X", + "02816": "AB889X", + "02817": "AB889X", + "02818": "AB889X", + "02822": "AB889X", + "02823": "AB889X", + "02824": "AB889X", + "02825": "AB889X", + "02826": "AB889X", + "02827": "AB889X", + "02828": "AB889X", + "02829": "AB889X", + "02830": "AB889X", + "02831": "AB889X", + "02832": "AB889X", + "02833": "AB889X", + "02835": "AB889X", + "02836": "AB889X", + "02837": "AB889X", + "02838": "AB889X", + "02839": "AB889X", + "02840": "AB889X", + "02841": "AB889X", + "02842": "AB889X", + "02852": "AB889X", + "02854": "AB889X", + "02857": "AB889X", + "02858": "AB889X", + "02859": "AB889X", + "02860": "AB889X", + "02861": "AB889X", + "02862": "AB889X", + "02863": "AB889X", + "02864": "AB889X", + "02865": "AB889X", + "02871": "AB889X", + "02872": "AB889X", + "02873": "AB889X", + "02874": "AB889X", + "02875": "AB889X", + "02876": "AB889X", + "02877": "AB889X", + "02878": "AB889X", + "02879": "AB889X", + "02880": "AB889X", + "02881": "AB889X", + "02882": "AB889X", + "02883": "AB889X", + "02885": "AB889X", + "02886": "AB889X", + "02887": "AB889X", + "02888": "AB889X", + "02889": "AB889X", + "02891": "AB889X", + "02892": "AB889X", + "02893": "AB889X", + "02894": "AB889X", + "02895": "AB889X", + "02896": "AB889X", + "02898": "AB889X", + "02901": "AB889X", + "02902": "AB889X", + "02903": "AB889X", + "02904": "AB889X", + "02905": "AB889X", + "02906": "AB889X", + "02907": "AB889X", + "02908": "AB889X", + "02909": "AB889X", + "02910": "AB889X", + "02911": "AB889X", + "02912": "AB889X", + "02914": "AB889X", + "02915": "AB889X", + "02916": "AB889X", + "02917": "AB889X", + "02918": "AB889X", + "02919": "AB889X", + "02920": "AB889X", + "02921": "AB889X", + "02940": "AB889X", + "03031": "AB889X", + "03032": "AB889X", + "03033": "AB889X", + "03034": "AB889X", + "03036": "AB889X", + "03037": "AB889X", + "03038": "AB889X", + "03040": "AB889X", + "03041": "AB889X", + "03042": "AB889X", + "03043": "AB889X", + "03044": "AB889X", + "03045": "AB889X", + "03046": "AB889X", + "03047": "AB889X", + "03048": "AB889X", + "03049": "AB889X", + "03051": "AB889X", + "03052": "AB889X", + "03053": "AB889X", + "03054": "AB889X", + "03055": "AB889X", + "03057": "AB889X", + "03060": "AB889X", + "03061": "AB889X", + "03062": "AB889X", + "03063": "AB889X", + "03064": "AB889X", + "03070": "AB889X", + "03071": "AB889X", + "03073": "AB889X", + "03076": "AB889X", + "03077": "AB889X", + "03079": "AB889X", + "03082": "AB889X", + "03084": "AB889X", + "03086": "AB889X", + "03087": "AB889X", + "03101": "AB889X", + "03102": "AB889X", + "03103": "AB889X", + "03104": "AB889X", + "03105": "AB889X", + "03106": "AB889X", + "03107": "AB889X", + "03108": "AB889X", + "03109": "AB889X", + "03110": "AB889X", + "03111": "AB889X", + "03215": "AB889X", + "03216": "AB889X", + "03217": "AB889X", + "03218": "AB889X", + "03220": "AB889X", + "03221": "AB889X", + "03222": "AB889X", + "03223": "AB889X", + "03224": "AB889X", + "03225": "AB889X", + "03226": "AB889X", + "03227": "AB889X", + "03229": "AB889X", + "03230": "AB889X", + "03231": "AB889X", + "03233": "AB889X", + "03234": "AB889X", + "03235": "AB889X", + "03237": "AB889X", + "03238": "AB889X", + "03240": "AB889X", + "03241": "AB889X", + "03242": "AB889X", + "03243": "AB889X", + "03244": "AB889X", + "03245": "AB889X", + "03246": "AB889X", + "03247": "AB889X", + "03249": "AB889X", + "03251": "AB889X", + "03252": "AB889X", + "03253": "AB889X", + "03254": "AB889X", + "03255": "AB889X", + "03256": "AB889X", + "03257": "AB889X", + "03258": "AB889X", + "03259": "AB889X", + "03260": "AB889X", + "03261": "AB889X", + "03262": "AB889X", + "03263": "AB889X", + "03264": "AB889X", + "03266": "AB889X", + "03268": "AB889X", + "03269": "AB889X", + "03272": "AB889X", + "03273": "AB889X", + "03274": "AB889X", + "03275": "AB889X", + "03276": "AB889X", + "03278": "AB889X", + "03279": "AB889X", + "03280": "AB889X", + "03281": "AB889X", + "03282": "AB889X", + "03284": "AB889X", + "03287": "AB889X", + "03289": "AB889X", + "03290": "AB889X", + "03291": "AB889X", + "03293": "AB889X", + "03298": "AB889X", + "03299": "AB889X", + "03301": "AB889X", + "03302": "AB889X", + "03303": "AB889X", + "03304": "AB889X", + "03305": "AB889X", + "03307": "AB889X", + "03431": "AB889X", + "03435": "AB889X", + "03440": "AB889X", + "03441": "AB889X", + "03442": "AB889X", + "03443": "AB889X", + "03444": "AB889X", + "03445": "AB889X", + "03446": "AB889X", + "03447": "AB889X", + "03448": "AB889X", + "03449": "AB889X", + "03450": "AB889X", + "03451": "AB889X", + "03452": "AB889X", + "03455": "AB889X", + "03456": "AB889X", + "03457": "AB889X", + "03458": "AB889X", + "03461": "AB889X", + "03462": "AB889X", + "03464": "AB889X", + "03465": "AB889X", + "03466": "AB889X", + "03467": "AB889X", + "03468": "AB889X", + "03469": "AB889X", + "03470": "AB889X", + "03561": "AB889X", + "03570": "AB889X", + "03574": "AB889X", + "03575": "AB889X", + "03576": "AB889X", + "03579": "AB889X", + "03580": "AB889X", + "03581": "AB889X", + "03582": "AB889X", + "03583": "AB889X", + "03584": "AB889X", + "03585": "AB889X", + "03586": "AB889X", + "03588": "AB889X", + "03589": "AB889X", + "03590": "AB889X", + "03592": "AB889X", + "03593": "AB889X", + "03595": "AB889X", + "03597": "AB889X", + "03598": "AB889X", + "03601": "AB889X", + "03602": "AB889X", + "03603": "AB889X", + "03604": "AB889X", + "03605": "AB889X", + "03607": "AB889X", + "03608": "AB889X", + "03609": "AB889X", + "03740": "AB889X", + "03741": "AB889X", + "03743": "AB889X", + "03745": "AB889X", + "03746": "AB889X", + "03748": "AB889X", + "03749": "AB889X", + "03750": "AB889X", + "03751": "AB889X", + "03752": "AB889X", + "03753": "AB889X", + "03754": "AB889X", + "03755": "AB889X", + "03756": "AB889X", + "03765": "AB889X", + "03766": "AB889X", + "03768": "AB889X", + "03769": "AB889X", + "03770": "AB889X", + "03771": "AB889X", + "03773": "AB889X", + "03774": "AB889X", + "03777": "AB889X", + "03779": "AB889X", + "03780": "AB889X", + "03781": "AB889X", + "03782": "AB889X", + "03784": "AB889X", + "03785": "AB889X", + "03801": "AB889X", + "03802": "AB889X", + "03803": "AB889X", + "03804": "AB889X", + "03805": "AB889X", + "03809": "AB889X", + "03810": "AB889X", + "03811": "AB889X", + "03812": "AB889X", + "03813": "AB889X", + "03814": "AB889X", + "03815": "AB889X", + "03816": "AB889X", + "03817": "AB889X", + "03818": "AB889X", + "03819": "AB889X", + "03820": "AB889X", + "03821": "AB889X", + "03822": "AB889X", + "03823": "AB889X", + "03824": "AB889X", + "03825": "AB889X", + "03826": "AB889X", + "03827": "AB889X", + "03830": "AB889X", + "03832": "AB889X", + "03833": "AB889X", + "03835": "AB889X", + "03836": "AB889X", + "03837": "AB889X", + "03838": "AB889X", + "03839": "AB889X", + "03840": "AB889X", + "03841": "AB889X", + "03842": "AB889X", + "03843": "AB889X", + "03844": "AB889X", + "03845": "AB889X", + "03846": "AB889X", + "03847": "AB889X", + "03848": "AB889X", + "03849": "AB889X", + "03850": "AB889X", + "03851": "AB889X", + "03852": "AB889X", + "03853": "AB889X", + "03854": "AB889X", + "03855": "AB889X", + "03856": "AB889X", + "03857": "AB889X", + "03858": "AB889X", + "03859": "AB889X", + "03860": "AB889X", + "03861": "AB889X", + "03862": "AB889X", + "03864": "AB889X", + "03865": "AB889X", + "03866": "AB889X", + "03867": "AB889X", + "03868": "AB889X", + "03869": "AB889X", + "03870": "AB889X", + "03871": "AB889X", + "03872": "AB889X", + "03873": "AB889X", + "03874": "AB889X", + "03875": "AB889X", + "03878": "AB889X", + "03882": "AB889X", + "03883": "AB889X", + "03884": "AB889X", + "03885": "AB889X", + "03886": "AB889X", + "03887": "AB889X", + "03890": "AB889X", + "03894": "AB889X", + "03896": "AB889X", + "03897": "AB889X", + "03901": "AB889X", + "03902": "AB889X", + "03903": "AB889X", + "03904": "AB889X", + "03905": "AB889X", + "03906": "AB889X", + "03907": "AB889X", + "03908": "AB889X", + "03909": "AB889X", + "03910": "AB889X", + "03911": "AB889X", + "04001": "AB889X", + "04002": "AB889X", + "04003": "AB889X", + "04004": "AB889X", + "04005": "AB889X", + "04006": "AB889X", + "04007": "AB889X", + "04008": "AB889X", + "04009": "AB889X", + "04010": "AB889X", + "04011": "AB889X", + "04013": "AB889X", + "04014": "AB889X", + "04015": "AB889X", + "04016": "AB889X", + "04017": "AB889X", + "04019": "AB889X", + "04020": "AB889X", + "04021": "AB889X", + "04022": "AB889X", + "04024": "AB889X", + "04027": "AB889X", + "04028": "AB889X", + "04029": "AB889X", + "04030": "AB889X", + "04032": "AB889X", + "04033": "AB889X", + "04034": "AB889X", + "04037": "AB889X", + "04038": "AB889X", + "04039": "AB889X", + "04040": "AB889X", + "04041": "AB889X", + "04042": "AB889X", + "04043": "AB889X", + "04046": "AB889X", + "04047": "AB889X", + "04048": "AB889X", + "04049": "AB889X", + "04050": "AB889X", + "04051": "AB889X", + "04054": "AB889X", + "04055": "AB889X", + "04056": "AB889X", + "04057": "AB889X", + "04061": "AB889X", + "04062": "AB889X", + "04063": "AB889X", + "04064": "AB889X", + "04066": "AB889X", + "04068": "AB889X", + "04069": "AB889X", + "04070": "AB889X", + "04071": "AB889X", + "04072": "AB889X", + "04073": "AB889X", + "04074": "AB889X", + "04075": "AB889X", + "04076": "AB889X", + "04077": "AB889X", + "04078": "AB889X", + "04079": "AB889X", + "04082": "AB889X", + "04083": "AB889X", + "04084": "AB889X", + "04085": "AB889X", + "04086": "AB889X", + "04087": "AB889X", + "04088": "AB889X", + "04090": "AB889X", + "04091": "AB889X", + "04092": "AB889X", + "04093": "AB889X", + "04094": "AB889X", + "04095": "AB889X", + "04096": "AB889X", + "04097": "AB889X", + "04098": "AB889X", + "04101": "AB889X", + "04102": "AB889X", + "04103": "AB889X", + "04104": "AB889X", + "04105": "AB889X", + "04106": "AB889X", + "04107": "AB889X", + "04108": "AB889X", + "04109": "AB889X", + "04110": "AB889X", + "04112": "AB889X", + "04116": "AB889X", + "04122": "AB889X", + "04123": "AB889X", + "04124": "AB889X", + "04210": "AB889X", + "04211": "AB889X", + "04212": "AB889X", + "04216": "AB889X", + "04217": "AB889X", + "04219": "AB889X", + "04220": "AB889X", + "04221": "AB889X", + "04222": "AB889X", + "04223": "AB889X", + "04224": "AB889X", + "04225": "AB889X", + "04226": "AB889X", + "04227": "AB889X", + "04228": "AB889X", + "04230": "AB889X", + "04231": "AB889X", + "04234": "AB889X", + "04236": "AB889X", + "04237": "AB889X", + "04238": "AB889X", + "04239": "AB889X", + "04240": "AB889X", + "04241": "AB889X", + "04243": "AB889X", + "04250": "AB889X", + "04252": "AB889X", + "04253": "AB889X", + "04254": "AB889X", + "04255": "AB889X", + "04256": "AB889X", + "04257": "AB889X", + "04258": "AB889X", + "04259": "AB889X", + "04260": "AB889X", + "04261": "AB889X", + "04262": "AB889X", + "04263": "AB889X", + "04265": "AB889X", + "04266": "AB889X", + "04267": "AB889X", + "04268": "AB889X", + "04270": "AB889X", + "04271": "AB889X", + "04274": "AB889X", + "04275": "AB889X", + "04276": "AB889X", + "04278": "AB889X", + "04280": "AB889X", + "04281": "AB889X", + "04282": "AB889X", + "04284": "AB889X", + "04285": "AB889X", + "04286": "AB889X", + "04287": "AB889X", + "04288": "AB889X", + "04289": "AB889X", + "04290": "AB889X", + "04291": "AB889X", + "04292": "AB889X", + "04294": "AB889X", + "04330": "AB889X", + "04332": "AB889X", + "04333": "AB889X", + "04336": "AB889X", + "04338": "AB889X", + "04341": "AB889X", + "04342": "AB889X", + "04343": "AB889X", + "04344": "AB889X", + "04345": "AB889X", + "04346": "AB889X", + "04347": "AB889X", + "04348": "AB889X", + "04349": "AB889X", + "04350": "AB889X", + "04351": "AB889X", + "04352": "AB889X", + "04353": "AB889X", + "04354": "AB889X", + "04355": "AB889X", + "04357": "AB889X", + "04358": "AB889X", + "04359": "AB889X", + "04360": "AB889X", + "04363": "AB889X", + "04364": "AB889X", + "04401": "AB889X", + "04402": "AB889X", + "04406": "AB889X", + "04408": "AB889X", + "04410": "AB889X", + "04411": "AB889X", + "04412": "AB889X", + "04413": "AB889X", + "04414": "AB889X", + "04415": "AB889X", + "04416": "AB889X", + "04417": "AB889X", + "04418": "AB889X", + "04419": "AB889X", + "04420": "AB889X", + "04421": "AB889X", + "04422": "AB889X", + "04424": "AB889X", + "04426": "AB889X", + "04427": "AB889X", + "04428": "AB889X", + "04429": "AB889X", + "04430": "AB889X", + "04431": "AB889X", + "04434": "AB889X", + "04435": "AB889X", + "04438": "AB889X", + "04441": "AB889X", + "04442": "AB889X", + "04443": "AB889X", + "04444": "AB889X", + "04448": "AB889X", + "04449": "AB889X", + "04450": "AB889X", + "04451": "AB889X", + "04453": "AB889X", + "04454": "AB889X", + "04455": "AB889X", + "04456": "AB889X", + "04457": "AB889X", + "04459": "AB889X", + "04460": "AB889X", + "04461": "AB889X", + "04462": "AB889X", + "04463": "AB889X", + "04464": "AB889X", + "04467": "AB889X", + "04468": "AB889X", + "04469": "AB889X", + "04471": "AB889X", + "04472": "AB889X", + "04473": "AB889X", + "04474": "AB889X", + "04475": "AB889X", + "04476": "AB889X", + "04478": "AB889X", + "04479": "AB889X", + "04481": "AB889X", + "04485": "AB889X", + "04487": "AB889X", + "04488": "AB889X", + "04489": "AB889X", + "04490": "AB889X", + "04491": "AB889X", + "04492": "AB889X", + "04493": "AB889X", + "04495": "AB889X", + "04496": "AB889X", + "04497": "AB889X", + "04530": "AB889X", + "04535": "AB889X", + "04537": "AB889X", + "04538": "AB889X", + "04539": "AB889X", + "04541": "AB889X", + "04543": "AB889X", + "04544": "AB889X", + "04547": "AB889X", + "04548": "AB889X", + "04549": "AB889X", + "04551": "AB889X", + "04553": "AB889X", + "04554": "AB889X", + "04555": "AB889X", + "04556": "AB889X", + "04558": "AB889X", + "04562": "AB889X", + "04563": "AB889X", + "04564": "AB889X", + "04565": "AB889X", + "04568": "AB889X", + "04570": "AB889X", + "04571": "AB889X", + "04572": "AB889X", + "04573": "AB889X", + "04574": "AB889X", + "04575": "AB889X", + "04576": "AB889X", + "04578": "AB889X", + "04579": "AB889X", + "04605": "AB889X", + "04606": "AB889X", + "04607": "AB889X", + "04609": "AB889X", + "04611": "AB889X", + "04612": "AB889X", + "04613": "AB889X", + "04614": "AB889X", + "04616": "AB889X", + "04617": "AB889X", + "04619": "AB889X", + "04622": "AB889X", + "04623": "AB889X", + "04624": "AB889X", + "04625": "AB889X", + "04626": "AB889X", + "04627": "AB889X", + "04628": "AB889X", + "04629": "AB889X", + "04630": "AB889X", + "04631": "AB889X", + "04634": "AB889X", + "04635": "AB889X", + "04637": "AB889X", + "04640": "AB889X", + "04642": "AB889X", + "04643": "AB889X", + "04644": "AB889X", + "04645": "AB889X", + "04646": "AB889X", + "04648": "AB889X", + "04649": "AB889X", + "04650": "AB889X", + "04652": "AB889X", + "04653": "AB889X", + "04654": "AB889X", + "04655": "AB889X", + "04657": "AB889X", + "04658": "AB889X", + "04660": "AB889X", + "04662": "AB889X", + "04664": "AB889X", + "04666": "AB889X", + "04667": "AB889X", + "04668": "AB889X", + "04669": "AB889X", + "04671": "AB889X", + "04672": "AB889X", + "04673": "AB889X", + "04674": "AB889X", + "04675": "AB889X", + "04676": "AB889X", + "04677": "AB889X", + "04679": "AB889X", + "04680": "AB889X", + "04681": "AB889X", + "04683": "AB889X", + "04684": "AB889X", + "04685": "AB889X", + "04686": "AB889X", + "04691": "AB889X", + "04693": "AB889X", + "04694": "AB889X", + "04730": "AB889X", + "04732": "AB889X", + "04733": "AB889X", + "04734": "AB889X", + "04735": "AB889X", + "04736": "AB889X", + "04737": "AB889X", + "04738": "AB889X", + "04739": "AB889X", + "04740": "AB889X", + "04741": "AB889X", + "04742": "AB889X", + "04743": "AB889X", + "04744": "AB889X", + "04745": "AB889X", + "04746": "AB889X", + "04747": "AB889X", + "04750": "AB889X", + "04751": "AB889X", + "04756": "AB889X", + "04757": "AB889X", + "04758": "AB889X", + "04760": "AB889X", + "04761": "AB889X", + "04762": "AB889X", + "04763": "AB889X", + "04764": "AB889X", + "04765": "AB889X", + "04766": "AB889X", + "04768": "AB889X", + "04769": "AB889X", + "04772": "AB889X", + "04773": "AB889X", + "04774": "AB889X", + "04775": "AB889X", + "04776": "AB889X", + "04777": "AB889X", + "04779": "AB889X", + "04780": "AB889X", + "04781": "AB889X", + "04783": "AB889X", + "04785": "AB889X", + "04786": "AB889X", + "04787": "AB889X", + "04841": "AB889X", + "04843": "AB889X", + "04846": "AB889X", + "04847": "AB889X", + "04848": "AB889X", + "04849": "AB889X", + "04850": "AB889X", + "04851": "AB889X", + "04852": "AB889X", + "04853": "AB889X", + "04854": "AB889X", + "04855": "AB889X", + "04856": "AB889X", + "04858": "AB889X", + "04859": "AB889X", + "04860": "AB889X", + "04861": "AB889X", + "04862": "AB889X", + "04863": "AB889X", + "04864": "AB889X", + "04865": "AB889X", + "04901": "AB889X", + "04903": "AB889X", + "04910": "AB889X", + "04911": "AB889X", + "04912": "AB889X", + "04915": "AB889X", + "04917": "AB889X", + "04918": "AB889X", + "04920": "AB889X", + "04921": "AB889X", + "04922": "AB889X", + "04923": "AB889X", + "04924": "AB889X", + "04925": "AB889X", + "04926": "AB889X", + "04927": "AB889X", + "04928": "AB889X", + "04929": "AB889X", + "04930": "AB889X", + "04932": "AB889X", + "04933": "AB889X", + "04935": "AB889X", + "04936": "AB889X", + "04937": "AB889X", + "04938": "AB889X", + "04939": "AB889X", + "04940": "AB889X", + "04941": "AB889X", + "04942": "AB889X", + "04943": "AB889X", + "04944": "AB889X", + "04945": "AB889X", + "04947": "AB889X", + "04949": "AB889X", + "04950": "AB889X", + "04951": "AB889X", + "04952": "AB889X", + "04953": "AB889X", + "04954": "AB889X", + "04955": "AB889X", + "04956": "AB889X", + "04957": "AB889X", + "04958": "AB889X", + "04961": "AB889X", + "04962": "AB889X", + "04963": "AB889X", + "04964": "AB889X", + "04965": "AB889X", + "04966": "AB889X", + "04967": "AB889X", + "04969": "AB889X", + "04970": "AB889X", + "04971": "AB889X", + "04972": "AB889X", + "04973": "AB889X", + "04974": "AB889X", + "04975": "AB889X", + "04976": "AB889X", + "04978": "AB889X", + "04979": "AB889X", + "04981": "AB889X", + "04982": "AB889X", + "04983": "AB889X", + "04984": "AB889X", + "04985": "AB889X", + "04986": "AB889X", + "04987": "AB889X", + "04988": "AB889X", + "04989": "AB889X", + "04992": "AB889X", + "05001": "AB889X", + "05009": "AB889X", + "05030": "AB889X", + "05031": "AB889X", + "05032": "AB889X", + "05033": "AB889X", + "05034": "AB889X", + "05035": "AB889X", + "05036": "AB889X", + "05037": "AB889X", + "05038": "AB889X", + "05039": "AB889X", + "05040": "AB889X", + "05041": "AB889X", + "05042": "AB889X", + "05043": "AB889X", + "05045": "AB889X", + "05046": "AB889X", + "05047": "AB889X", + "05048": "AB889X", + "05049": "AB889X", + "05050": "AB889X", + "05051": "AB889X", + "05052": "AB889X", + "05053": "AB889X", + "05054": "AB889X", + "05055": "AB889X", + "05056": "AB889X", + "05058": "AB889X", + "05059": "AB889X", + "05060": "AB889X", + "05061": "AB889X", + "05062": "AB889X", + "05065": "AB889X", + "05067": "AB889X", + "05068": "AB889X", + "05069": "AB889X", + "05070": "AB889X", + "05071": "AB889X", + "05072": "AB889X", + "05073": "AB889X", + "05074": "AB889X", + "05075": "AB889X", + "05076": "AB889X", + "05077": "AB889X", + "05079": "AB889X", + "05081": "AB889X", + "05083": "AB889X", + "05084": "AB889X", + "05085": "AB889X", + "05086": "AB889X", + "05088": "AB889X", + "05089": "AB889X", + "05091": "AB889X", + "05101": "AB889X", + "05141": "AB889X", + "05142": "AB889X", + "05143": "AB889X", + "05144": "AB889X", + "05146": "AB889X", + "05148": "AB889X", + "05149": "AB889X", + "05150": "AB889X", + "05151": "AB889X", + "05152": "AB889X", + "05153": "AB889X", + "05154": "AB889X", + "05155": "AB889X", + "05156": "AB889X", + "05158": "AB889X", + "05159": "AB889X", + "05161": "AB889X", + "05201": "AB889X", + "05250": "AB889X", + "05251": "AB889X", + "05252": "AB889X", + "05253": "AB889X", + "05254": "AB889X", + "05255": "AB889X", + "05257": "AB889X", + "05260": "AB889X", + "05261": "AB889X", + "05262": "AB889X", + "05301": "AB889X", + "05302": "AB889X", + "05303": "AB889X", + "05304": "AB889X", + "05340": "AB889X", + "05341": "AB889X", + "05342": "AB889X", + "05343": "AB889X", + "05344": "AB889X", + "05345": "AB889X", + "05346": "AB889X", + "05350": "AB889X", + "05351": "AB889X", + "05352": "AB889X", + "05353": "AB889X", + "05354": "AB889X", + "05355": "AB889X", + "05356": "AB889X", + "05357": "AB889X", + "05358": "AB889X", + "05359": "AB889X", + "05360": "AB889X", + "05361": "AB889X", + "05362": "AB889X", + "05363": "AB889X", + "05401": "AB889X", + "05402": "AB889X", + "05403": "AB889X", + "05404": "AB889X", + "05405": "AB889X", + "05406": "AB889X", + "05407": "AB889X", + "05408": "AB889X", + "05439": "AB889X", + "05440": "AB889X", + "05441": "AB889X", + "05442": "AB889X", + "05443": "AB889X", + "05444": "AB889X", + "05445": "AB889X", + "05446": "AB889X", + "05447": "AB889X", + "05448": "AB889X", + "05449": "AB889X", + "05450": "AB889X", + "05451": "AB889X", + "05452": "AB889X", + "05453": "AB889X", + "05454": "AB889X", + "05455": "AB889X", + "05456": "AB889X", + "05457": "AB889X", + "05458": "AB889X", + "05459": "AB889X", + "05460": "AB889X", + "05461": "AB889X", + "05462": "AB889X", + "05463": "AB889X", + "05464": "AB889X", + "05465": "AB889X", + "05466": "AB889X", + "05468": "AB889X", + "05469": "AB889X", + "05470": "AB889X", + "05471": "AB889X", + "05472": "AB889X", + "05473": "AB889X", + "05474": "AB889X", + "05476": "AB889X", + "05477": "AB889X", + "05478": "AB889X", + "05479": "AB889X", + "05481": "AB889X", + "05482": "AB889X", + "05483": "AB889X", + "05485": "AB889X", + "05486": "AB889X", + "05487": "AB889X", + "05488": "AB889X", + "05489": "AB889X", + "05490": "AB889X", + "05491": "AB889X", + "05492": "AB889X", + "05494": "AB889X", + "05495": "AB889X", + "05501": "AB889X", + "05544": "AB889X", + "05601": "AB889X", + "05602": "AB889X", + "05603": "AB889X", + "05604": "AB889X", + "05609": "AB889X", + "05620": "AB889X", + "05633": "AB889X", + "05640": "AB889X", + "05641": "AB889X", + "05647": "AB889X", + "05648": "AB889X", + "05649": "AB889X", + "05650": "AB889X", + "05651": "AB889X", + "05652": "AB889X", + "05653": "AB889X", + "05654": "AB889X", + "05655": "AB889X", + "05656": "AB889X", + "05657": "AB889X", + "05658": "AB889X", + "05660": "AB889X", + "05661": "AB889X", + "05662": "AB889X", + "05663": "AB889X", + "05664": "AB889X", + "05665": "AB889X", + "05666": "AB889X", + "05667": "AB889X", + "05669": "AB889X", + "05670": "AB889X", + "05671": "AB889X", + "05672": "AB889X", + "05673": "AB889X", + "05674": "AB889X", + "05675": "AB889X", + "05676": "AB889X", + "05677": "AB889X", + "05678": "AB889X", + "05679": "AB889X", + "05680": "AB889X", + "05681": "AB889X", + "05682": "AB889X", + "05701": "AB889X", + "05702": "AB889X", + "05730": "AB889X", + "05731": "AB889X", + "05732": "AB889X", + "05733": "AB889X", + "05734": "AB889X", + "05735": "AB889X", + "05736": "AB889X", + "05737": "AB889X", + "05738": "AB889X", + "05739": "AB889X", + "05740": "AB889X", + "05741": "AB889X", + "05742": "AB889X", + "05743": "AB889X", + "05744": "AB889X", + "05745": "AB889X", + "05746": "AB889X", + "05747": "AB889X", + "05748": "AB889X", + "05750": "AB889X", + "05751": "AB889X", + "05753": "AB889X", + "05757": "AB889X", + "05758": "AB889X", + "05759": "AB889X", + "05760": "AB889X", + "05761": "AB889X", + "05762": "AB889X", + "05763": "AB889X", + "05764": "AB889X", + "05765": "AB889X", + "05766": "AB889X", + "05767": "AB889X", + "05768": "AB889X", + "05769": "AB889X", + "05770": "AB889X", + "05772": "AB889X", + "05773": "AB889X", + "05774": "AB889X", + "05775": "AB889X", + "05776": "AB889X", + "05777": "AB889X", + "05778": "AB889X", + "05819": "AB889X", + "05820": "AB889X", + "05821": "AB889X", + "05822": "AB889X", + "05823": "AB889X", + "05824": "AB889X", + "05825": "AB889X", + "05826": "AB889X", + "05827": "AB889X", + "05828": "AB889X", + "05829": "AB889X", + "05830": "AB889X", + "05832": "AB889X", + "05833": "AB889X", + "05836": "AB889X", + "05837": "AB889X", + "05838": "AB889X", + "05839": "AB889X", + "05840": "AB889X", + "05841": "AB889X", + "05842": "AB889X", + "05843": "AB889X", + "05845": "AB889X", + "05846": "AB889X", + "05847": "AB889X", + "05848": "AB889X", + "05849": "AB889X", + "05850": "AB889X", + "05851": "AB889X", + "05853": "AB889X", + "05855": "AB889X", + "05857": "AB889X", + "05858": "AB889X", + "05859": "AB889X", + "05860": "AB889X", + "05861": "AB889X", + "05862": "AB889X", + "05863": "AB889X", + "05866": "AB889X", + "05867": "AB889X", + "05868": "AB889X", + "05871": "AB889X", + "05872": "AB889X", + "05873": "AB889X", + "05874": "AB889X", + "05875": "AB889X", + "05901": "AB889X", + "05902": "AB889X", + "05903": "AB889X", + "05904": "AB889X", + "05905": "AB889X", + "05906": "AB889X", + "05907": "AB889X", + "06001": "AB890X", + "06002": "AB890X", + "06006": "AB890X", + "06010": "AB890X", + "06011": "AB890X", + "06013": "AB890X", + "06016": "AB890X", + "06018": "AB890X", + "06019": "AB890X", + "06020": "AB890X", + "06021": "AB890X", + "06022": "AB890X", + "06023": "AB890X", + "06024": "AB890X", + "06025": "AB890X", + "06026": "AB890X", + "06027": "AB890X", + "06028": "AB890X", + "06029": "AB890X", + "06030": "AB890X", + "06031": "AB890X", + "06032": "AB890X", + "06033": "AB890X", + "06034": "AB890X", + "06035": "AB890X", + "06037": "AB890X", + "06039": "AB890X", + "06040": "AB890X", + "06041": "AB890X", + "06042": "AB890X", + "06043": "AB890X", + "06045": "AB890X", + "06050": "AB890X", + "06051": "AB890X", + "06052": "AB890X", + "06053": "AB890X", + "06057": "AB890X", + "06058": "AB890X", + "06059": "AB890X", + "06060": "AB890X", + "06061": "AB890X", + "06062": "AB890X", + "06063": "AB890X", + "06064": "AB890X", + "06065": "AB890X", + "06066": "AB890X", + "06067": "AB890X", + "06068": "AB890X", + "06069": "AB890X", + "06070": "AB890X", + "06071": "AB890X", + "06072": "AB890X", + "06073": "AB890X", + "06074": "AB890X", + "06075": "AB890X", + "06076": "AB890X", + "06077": "AB890X", + "06078": "AB890X", + "06079": "AB890X", + "06080": "AB890X", + "06081": "AB890X", + "06082": "AB890X", + "06083": "AB890X", + "06084": "AB890X", + "06085": "AB890X", + "06087": "AB890X", + "06088": "AB890X", + "06089": "AB890X", + "06090": "AB890X", + "06091": "AB890X", + "06092": "AB890X", + "06093": "AB890X", + "06094": "AB890X", + "06095": "AB890X", + "06096": "AB890X", + "06098": "AB890X", + "06101": "AB890X", + "06102": "AB890X", + "06103": "AB890X", + "06104": "AB890X", + "06105": "AB890X", + "06106": "AB890X", + "06107": "AB890X", + "06108": "AB890X", + "06109": "AB890X", + "06110": "AB890X", + "06111": "AB890X", + "06112": "AB890X", + "06114": "AB890X", + "06115": "AB890X", + "06117": "AB890X", + "06118": "AB890X", + "06119": "AB890X", + "06120": "AB890X", + "06123": "AB890X", + "06126": "AB890X", + "06127": "AB890X", + "06128": "AB890X", + "06129": "AB890X", + "06131": "AB890X", + "06132": "AB890X", + "06133": "AB890X", + "06134": "AB890X", + "06137": "AB890X", + "06138": "AB890X", + "06140": "AB890X", + "06141": "AB890X", + "06142": "AB890X", + "06143": "AB890X", + "06144": "AB890X", + "06145": "AB890X", + "06146": "AB890X", + "06147": "AB890X", + "06150": "AB890X", + "06151": "AB890X", + "06152": "AB890X", + "06153": "AB890X", + "06154": "AB890X", + "06155": "AB890X", + "06156": "AB890X", + "06160": "AB890X", + "06161": "AB890X", + "06167": "AB890X", + "06176": "AB890X", + "06180": "AB890X", + "06183": "AB890X", + "06199": "AB890X", + "06226": "AB890X", + "06230": "AB890X", + "06231": "AB890X", + "06232": "AB890X", + "06233": "AB890X", + "06234": "AB890X", + "06235": "AB890X", + "06237": "AB890X", + "06238": "AB890X", + "06239": "AB890X", + "06241": "AB890X", + "06242": "AB890X", + "06243": "AB890X", + "06244": "AB890X", + "06245": "AB890X", + "06246": "AB890X", + "06247": "AB890X", + "06248": "AB890X", + "06249": "AB890X", + "06250": "AB890X", + "06251": "AB890X", + "06254": "AB890X", + "06255": "AB890X", + "06256": "AB890X", + "06258": "AB890X", + "06259": "AB890X", + "06260": "AB890X", + "06262": "AB890X", + "06263": "AB890X", + "06264": "AB890X", + "06265": "AB890X", + "06266": "AB890X", + "06267": "AB890X", + "06268": "AB890X", + "06269": "AB890X", + "06277": "AB890X", + "06278": "AB890X", + "06279": "AB890X", + "06280": "AB890X", + "06281": "AB890X", + "06282": "AB890X", + "06320": "AB890X", + "06330": "AB890X", + "06331": "AB890X", + "06332": "AB890X", + "06333": "AB890X", + "06334": "AB890X", + "06335": "AB890X", + "06336": "AB890X", + "06338": "AB890X", + "06339": "AB890X", + "06340": "AB890X", + "06349": "AB890X", + "06350": "AB890X", + "06351": "AB890X", + "06353": "AB890X", + "06354": "AB890X", + "06355": "AB890X", + "06357": "AB890X", + "06359": "AB890X", + "06360": "AB890X", + "06365": "AB890X", + "06370": "AB890X", + "06371": "AB890X", + "06372": "AB890X", + "06373": "AB890X", + "06374": "AB890X", + "06375": "AB890X", + "06376": "AB890X", + "06377": "AB890X", + "06378": "AB890X", + "06379": "AB890X", + "06380": "AB890X", + "06382": "AB890X", + "06383": "AB890X", + "06384": "AB890X", + "06385": "AB890X", + "06386": "AB890X", + "06387": "AB890X", + "06388": "AB890X", + "06389": "AB890X", + "06390": "AB890X", + "06401": "AB890X", + "06403": "AB890X", + "06404": "AB890X", + "06405": "AB890X", + "06408": "AB890X", + "06409": "AB890X", + "06410": "AB890X", + "06411": "AB890X", + "06412": "AB890X", + "06413": "AB890X", + "06414": "AB890X", + "06415": "AB890X", + "06416": "AB890X", + "06417": "AB890X", + "06418": "AB890X", + "06419": "AB890X", + "06420": "AB890X", + "06422": "AB890X", + "06423": "AB890X", + "06424": "AB890X", + "06426": "AB890X", + "06437": "AB890X", + "06438": "AB890X", + "06439": "AB890X", + "06440": "AB890X", + "06441": "AB890X", + "06442": "AB890X", + "06443": "AB890X", + "06444": "AB890X", + "06447": "AB890X", + "06450": "AB890X", + "06451": "AB890X", + "06454": "AB890X", + "06455": "AB890X", + "06456": "AB890X", + "06457": "AB890X", + "06459": "AB890X", + "06460": "AB890X", + "06461": "AB890X", + "06467": "AB890X", + "06468": "AB890X", + "06469": "AB890X", + "06470": "AB890X", + "06471": "AB890X", + "06472": "AB890X", + "06473": "AB890X", + "06474": "AB890X", + "06475": "AB890X", + "06477": "AB890X", + "06478": "AB890X", + "06479": "AB890X", + "06480": "AB890X", + "06481": "AB890X", + "06482": "AB890X", + "06483": "AB890X", + "06484": "AB890X", + "06487": "AB890X", + "06488": "AB890X", + "06489": "AB890X", + "06491": "AB890X", + "06492": "AB890X", + "06493": "AB890X", + "06494": "AB890X", + "06495": "AB890X", + "06497": "AB890X", + "06498": "AB890X", + "06501": "AB890X", + "06502": "AB890X", + "06503": "AB890X", + "06504": "AB890X", + "06505": "AB890X", + "06506": "AB890X", + "06507": "AB890X", + "06508": "AB890X", + "06509": "AB890X", + "06510": "AB890X", + "06511": "AB890X", + "06512": "AB890X", + "06513": "AB890X", + "06514": "AB890X", + "06515": "AB890X", + "06516": "AB890X", + "06517": "AB890X", + "06518": "AB890X", + "06519": "AB890X", + "06520": "AB890X", + "06521": "AB890X", + "06524": "AB890X", + "06525": "AB890X", + "06530": "AB890X", + "06531": "AB890X", + "06532": "AB890X", + "06533": "AB890X", + "06534": "AB890X", + "06535": "AB890X", + "06536": "AB890X", + "06537": "AB890X", + "06538": "AB890X", + "06540": "AB890X", + "06601": "AB890X", + "06602": "AB890X", + "06604": "AB890X", + "06605": "AB890X", + "06606": "AB890X", + "06607": "AB890X", + "06608": "AB890X", + "06610": "AB890X", + "06611": "AB890X", + "06612": "AB890X", + "06614": "AB890X", + "06615": "AB890X", + "06650": "AB890X", + "06673": "AB890X", + "06699": "AB890X", + "06701": "AB890X", + "06702": "AB890X", + "06703": "AB890X", + "06704": "AB890X", + "06705": "AB890X", + "06706": "AB890X", + "06708": "AB890X", + "06710": "AB890X", + "06712": "AB890X", + "06716": "AB890X", + "06720": "AB890X", + "06721": "AB890X", + "06722": "AB890X", + "06723": "AB890X", + "06724": "AB890X", + "06725": "AB890X", + "06726": "AB890X", + "06749": "AB890X", + "06750": "AB890X", + "06751": "AB890X", + "06752": "AB890X", + "06753": "AB890X", + "06754": "AB890X", + "06755": "AB890X", + "06756": "AB890X", + "06757": "AB890X", + "06758": "AB890X", + "06759": "AB890X", + "06762": "AB890X", + "06763": "AB890X", + "06770": "AB890X", + "06776": "AB890X", + "06777": "AB890X", + "06778": "AB890X", + "06779": "AB890X", + "06781": "AB890X", + "06782": "AB890X", + "06783": "AB890X", + "06784": "AB890X", + "06785": "AB890X", + "06786": "AB890X", + "06787": "AB890X", + "06790": "AB890X", + "06791": "AB890X", + "06792": "AB890X", + "06793": "AB890X", + "06794": "AB890X", + "06795": "AB890X", + "06796": "AB890X", + "06798": "AB890X", + "06801": "AB890X", + "06804": "AB890X", + "06807": "AB890X", + "06810": "AB890X", + "06811": "AB890X", + "06812": "AB890X", + "06813": "AB890X", + "06814": "AB890X", + "06816": "AB890X", + "06817": "AB890X", + "06820": "AB890X", + "06824": "AB890X", + "06825": "AB890X", + "06828": "AB890X", + "06829": "AB890X", + "06830": "AB890X", + "06831": "AB890X", + "06832": "AB890X", + "06836": "AB890X", + "06838": "AB890X", + "06840": "AB890X", + "06842": "AB890X", + "06850": "AB890X", + "06851": "AB890X", + "06852": "AB890X", + "06853": "AB890X", + "06854": "AB890X", + "06855": "AB890X", + "06856": "AB890X", + "06857": "AB890X", + "06858": "AB890X", + "06859": "AB890X", + "06860": "AB890X", + "06870": "AB890X", + "06875": "AB890X", + "06876": "AB890X", + "06877": "AB890X", + "06878": "AB890X", + "06879": "AB890X", + "06880": "AB890X", + "06881": "AB890X", + "06883": "AB890X", + "06888": "AB890X", + "06889": "AB890X", + "06890": "AB890X", + "06896": "AB890X", + "06897": "AB890X", + "06901": "AB890X", + "06902": "AB890X", + "06903": "AB890X", + "06904": "AB890X", + "06905": "AB890X", + "06906": "AB890X", + "06907": "AB890X", + "06910": "AB890X", + "06911": "AB890X", + "06912": "AB890X", + "06913": "AB890X", + "06914": "AB890X", + "06920": "AB890X", + "06921": "AB890X", + "06922": "AB890X", + "06925": "AB890X", + "06926": "AB890X", + "06927": "AB890X", + "06928": "AB890X", + "07001": "AB890X", + "07002": "AB890X", + "07003": "AB890X", + "07004": "AB890X", + "07005": "AB890X", + "07006": "AB890X", + "07007": "AB890X", + "07008": "AB890X", + "07009": "AB890X", + "07010": "AB890X", + "07011": "AB890X", + "07012": "AB890X", + "07013": "AB890X", + "07014": "AB890X", + "07015": "AB890X", + "07016": "AB890X", + "07017": "AB890X", + "07018": "AB890X", + "07019": "AB890X", + "07020": "AB890X", + "07021": "AB890X", + "07022": "AB890X", + "07023": "AB890X", + "07024": "AB890X", + "07026": "AB890X", + "07027": "AB890X", + "07028": "AB890X", + "07029": "AB890X", + "07030": "AB890X", + "07031": "AB890X", + "07032": "AB890X", + "07033": "AB890X", + "07034": "AB890X", + "07035": "AB890X", + "07036": "AB890X", + "07039": "AB890X", + "07040": "AB890X", + "07041": "AB890X", + "07042": "AB890X", + "07043": "AB890X", + "07044": "AB890X", + "07045": "AB890X", + "07046": "AB890X", + "07047": "AB890X", + "07050": "AB890X", + "07051": "AB890X", + "07052": "AB890X", + "07054": "AB890X", + "07055": "AB890X", + "07057": "AB890X", + "07058": "AB890X", + "07059": "AB890X", + "07060": "AB890X", + "07061": "AB890X", + "07062": "AB890X", + "07063": "AB890X", + "07064": "AB890X", + "07065": "AB890X", + "07066": "AB890X", + "07067": "AB890X", + "07068": "AB890X", + "07069": "AB890X", + "07070": "AB890X", + "07071": "AB890X", + "07072": "AB890X", + "07073": "AB890X", + "07074": "AB890X", + "07075": "AB890X", + "07076": "AB890X", + "07077": "AB890X", + "07078": "AB890X", + "07079": "AB890X", + "07080": "AB890X", + "07081": "AB890X", + "07082": "AB890X", + "07083": "AB890X", + "07086": "AB890X", + "07087": "AB890X", + "07088": "AB890X", + "07090": "AB890X", + "07091": "AB890X", + "07092": "AB890X", + "07093": "AB890X", + "07094": "AB890X", + "07095": "AB890X", + "07096": "AB890X", + "07097": "AB890X", + "07099": "AB890X", + "07101": "AB890X", + "07102": "AB890X", + "07103": "AB890X", + "07104": "AB890X", + "07105": "AB890X", + "07106": "AB890X", + "07107": "AB890X", + "07108": "AB890X", + "07109": "AB890X", + "07110": "AB890X", + "07111": "AB890X", + "07112": "AB890X", + "07114": "AB890X", + "07175": "AB890X", + "07182": "AB890X", + "07184": "AB890X", + "07188": "AB890X", + "07189": "AB890X", + "07191": "AB890X", + "07192": "AB890X", + "07193": "AB890X", + "07194": "AB890X", + "07195": "AB890X", + "07198": "AB890X", + "07199": "AB890X", + "07201": "AB890X", + "07202": "AB890X", + "07203": "AB890X", + "07204": "AB890X", + "07205": "AB890X", + "07206": "AB890X", + "07207": "AB890X", + "07208": "AB890X", + "07302": "AB890X", + "07303": "AB890X", + "07304": "AB890X", + "07305": "AB890X", + "07306": "AB890X", + "07307": "AB890X", + "07308": "AB890X", + "07309": "AB890X", + "07310": "AB890X", + "07311": "AB890X", + "07395": "AB890X", + "07399": "AB890X", + "07401": "AB890X", + "07403": "AB890X", + "07405": "AB890X", + "07407": "AB890X", + "07410": "AB890X", + "07416": "AB890X", + "07417": "AB890X", + "07418": "AB890X", + "07419": "AB890X", + "07420": "AB890X", + "07421": "AB890X", + "07422": "AB890X", + "07423": "AB890X", + "07424": "AB890X", + "07428": "AB890X", + "07430": "AB890X", + "07432": "AB890X", + "07435": "AB890X", + "07436": "AB890X", + "07438": "AB890X", + "07439": "AB890X", + "07440": "AB890X", + "07442": "AB890X", + "07444": "AB890X", + "07446": "AB890X", + "07450": "AB890X", + "07451": "AB890X", + "07452": "AB890X", + "07456": "AB890X", + "07457": "AB890X", + "07458": "AB890X", + "07460": "AB890X", + "07461": "AB890X", + "07462": "AB890X", + "07463": "AB890X", + "07465": "AB890X", + "07470": "AB890X", + "07474": "AB890X", + "07477": "AB890X", + "07480": "AB890X", + "07481": "AB890X", + "07495": "AB890X", + "07501": "AB890X", + "07502": "AB890X", + "07503": "AB890X", + "07504": "AB890X", + "07505": "AB890X", + "07506": "AB890X", + "07507": "AB890X", + "07508": "AB890X", + "07509": "AB890X", + "07510": "AB890X", + "07511": "AB890X", + "07512": "AB890X", + "07513": "AB890X", + "07514": "AB890X", + "07522": "AB890X", + "07524": "AB890X", + "07533": "AB890X", + "07538": "AB890X", + "07543": "AB890X", + "07544": "AB890X", + "07601": "AB890X", + "07602": "AB890X", + "07603": "AB890X", + "07604": "AB890X", + "07605": "AB890X", + "07606": "AB890X", + "07607": "AB890X", + "07608": "AB890X", + "07620": "AB890X", + "07621": "AB890X", + "07624": "AB890X", + "07626": "AB890X", + "07627": "AB890X", + "07628": "AB890X", + "07630": "AB890X", + "07631": "AB890X", + "07632": "AB890X", + "07640": "AB890X", + "07641": "AB890X", + "07642": "AB890X", + "07643": "AB890X", + "07644": "AB890X", + "07645": "AB890X", + "07646": "AB890X", + "07647": "AB890X", + "07648": "AB890X", + "07649": "AB890X", + "07650": "AB890X", + "07652": "AB890X", + "07653": "AB890X", + "07656": "AB890X", + "07657": "AB890X", + "07660": "AB890X", + "07661": "AB890X", + "07662": "AB890X", + "07663": "AB890X", + "07666": "AB890X", + "07670": "AB890X", + "07675": "AB890X", + "07676": "AB890X", + "07677": "AB890X", + "07699": "AB890X", + "07701": "AB890X", + "07702": "AB890X", + "07703": "AB890X", + "07704": "AB890X", + "07709": "AB890X", + "07710": "AB890X", + "07711": "AB890X", + "07712": "AB890X", + "07715": "AB890X", + "07716": "AB890X", + "07717": "AB890X", + "07718": "AB890X", + "07719": "AB890X", + "07720": "AB890X", + "07721": "AB890X", + "07722": "AB890X", + "07723": "AB890X", + "07724": "AB890X", + "07726": "AB890X", + "07727": "AB890X", + "07728": "AB890X", + "07730": "AB890X", + "07731": "AB890X", + "07732": "AB890X", + "07733": "AB890X", + "07734": "AB890X", + "07735": "AB890X", + "07737": "AB890X", + "07738": "AB890X", + "07739": "AB890X", + "07740": "AB890X", + "07746": "AB890X", + "07747": "AB890X", + "07748": "AB890X", + "07750": "AB890X", + "07751": "AB890X", + "07752": "AB890X", + "07753": "AB890X", + "07754": "AB890X", + "07755": "AB890X", + "07756": "AB890X", + "07757": "AB890X", + "07758": "AB890X", + "07760": "AB890X", + "07762": "AB890X", + "07763": "AB890X", + "07764": "AB890X", + "07765": "AB890X", + "07777": "AB890X", + "07799": "AB890X", + "07801": "AB890X", + "07802": "AB890X", + "07803": "AB890X", + "07806": "AB890X", + "07820": "AB890X", + "07821": "AB890X", + "07822": "AB890X", + "07823": "AB890X", + "07825": "AB890X", + "07826": "AB890X", + "07827": "AB890X", + "07828": "AB890X", + "07829": "AB890X", + "07830": "AB890X", + "07831": "AB890X", + "07832": "AB890X", + "07833": "AB890X", + "07834": "AB890X", + "07836": "AB890X", + "07837": "AB890X", + "07838": "AB890X", + "07839": "AB890X", + "07840": "AB890X", + "07842": "AB890X", + "07843": "AB890X", + "07844": "AB890X", + "07845": "AB890X", + "07846": "AB890X", + "07847": "AB890X", + "07848": "AB890X", + "07849": "AB890X", + "07850": "AB890X", + "07851": "AB890X", + "07852": "AB890X", + "07853": "AB890X", + "07855": "AB890X", + "07856": "AB890X", + "07857": "AB890X", + "07860": "AB890X", + "07863": "AB890X", + "07865": "AB890X", + "07866": "AB890X", + "07869": "AB890X", + "07870": "AB890X", + "07871": "AB890X", + "07874": "AB890X", + "07875": "AB890X", + "07876": "AB890X", + "07877": "AB890X", + "07878": "AB890X", + "07879": "AB890X", + "07880": "AB890X", + "07881": "AB890X", + "07882": "AB890X", + "07885": "AB890X", + "07890": "AB890X", + "07901": "AB890X", + "07902": "AB890X", + "07920": "AB890X", + "07921": "AB890X", + "07922": "AB890X", + "07924": "AB890X", + "07926": "AB890X", + "07927": "AB890X", + "07928": "AB890X", + "07930": "AB890X", + "07931": "AB890X", + "07932": "AB890X", + "07933": "AB890X", + "07934": "AB890X", + "07935": "AB890X", + "07936": "AB890X", + "07938": "AB890X", + "07939": "AB890X", + "07940": "AB890X", + "07945": "AB890X", + "07946": "AB890X", + "07950": "AB890X", + "07960": "AB890X", + "07961": "AB890X", + "07962": "AB890X", + "07963": "AB890X", + "07970": "AB890X", + "07974": "AB890X", + "07976": "AB890X", + "07977": "AB890X", + "07978": "AB890X", + "07979": "AB890X", + "07980": "AB890X", + "07981": "AB890X", + "07983": "AB890X", + "07999": "AB890X", + "08001": "AB890X", + "08002": "AB890X", + "08003": "AB890X", + "08004": "AB890X", + "08005": "AB890X", + "08006": "AB890X", + "08007": "AB890X", + "08008": "AB890X", + "08009": "AB890X", + "08010": "AB890X", + "08011": "AB890X", + "08012": "AB890X", + "08014": "AB890X", + "08015": "AB890X", + "08016": "AB890X", + "08018": "AB890X", + "08019": "AB890X", + "08020": "AB890X", + "08021": "AB890X", + "08022": "AB890X", + "08023": "AB890X", + "08025": "AB890X", + "08026": "AB890X", + "08027": "AB890X", + "08028": "AB890X", + "08029": "AB890X", + "08030": "AB890X", + "08031": "AB890X", + "08032": "AB890X", + "08033": "AB890X", + "08034": "AB890X", + "08035": "AB890X", + "08036": "AB890X", + "08037": "AB890X", + "08038": "AB890X", + "08039": "AB890X", + "08041": "AB890X", + "08042": "AB890X", + "08043": "AB890X", + "08045": "AB890X", + "08046": "AB890X", + "08048": "AB890X", + "08049": "AB890X", + "08050": "AB890X", + "08051": "AB890X", + "08052": "AB890X", + "08053": "AB890X", + "08054": "AB890X", + "08055": "AB890X", + "08056": "AB890X", + "08057": "AB890X", + "08059": "AB890X", + "08060": "AB890X", + "08061": "AB890X", + "08062": "AB890X", + "08063": "AB890X", + "08064": "AB890X", + "08065": "AB890X", + "08066": "AB890X", + "08067": "AB890X", + "08068": "AB890X", + "08069": "AB890X", + "08070": "AB890X", + "08071": "AB890X", + "08072": "AB890X", + "08073": "AB890X", + "08074": "AB890X", + "08075": "AB890X", + "08076": "AB890X", + "08077": "AB890X", + "08078": "AB890X", + "08079": "AB890X", + "08080": "AB890X", + "08081": "AB890X", + "08083": "AB890X", + "08084": "AB890X", + "08085": "AB890X", + "08086": "AB890X", + "08087": "AB890X", + "08088": "AB890X", + "08089": "AB890X", + "08090": "AB890X", + "08091": "AB890X", + "08092": "AB890X", + "08093": "AB890X", + "08094": "AB890X", + "08095": "AB890X", + "08096": "AB890X", + "08097": "AB890X", + "08098": "AB890X", + "08099": "AB890X", + "08101": "AB890X", + "08102": "AB890X", + "08103": "AB890X", + "08104": "AB890X", + "08105": "AB890X", + "08106": "AB890X", + "08107": "AB890X", + "08108": "AB890X", + "08109": "AB890X", + "08110": "AB890X", + "08201": "AB890X", + "08202": "AB890X", + "08203": "AB890X", + "08204": "AB890X", + "08205": "AB890X", + "08210": "AB890X", + "08212": "AB890X", + "08213": "AB890X", + "08214": "AB890X", + "08215": "AB890X", + "08217": "AB890X", + "08218": "AB890X", + "08219": "AB890X", + "08220": "AB890X", + "08221": "AB890X", + "08223": "AB890X", + "08224": "AB890X", + "08225": "AB890X", + "08226": "AB890X", + "08230": "AB890X", + "08231": "AB890X", + "08232": "AB890X", + "08234": "AB890X", + "08240": "AB890X", + "08241": "AB890X", + "08242": "AB890X", + "08243": "AB890X", + "08244": "AB890X", + "08245": "AB890X", + "08246": "AB890X", + "08247": "AB890X", + "08248": "AB890X", + "08250": "AB890X", + "08251": "AB890X", + "08252": "AB890X", + "08260": "AB890X", + "08270": "AB890X", + "08302": "AB890X", + "08310": "AB890X", + "08311": "AB890X", + "08312": "AB890X", + "08313": "AB890X", + "08314": "AB890X", + "08315": "AB890X", + "08316": "AB890X", + "08317": "AB890X", + "08318": "AB890X", + "08319": "AB890X", + "08320": "AB890X", + "08321": "AB890X", + "08322": "AB890X", + "08323": "AB890X", + "08324": "AB890X", + "08326": "AB890X", + "08327": "AB890X", + "08328": "AB890X", + "08329": "AB890X", + "08330": "AB890X", + "08332": "AB890X", + "08340": "AB890X", + "08341": "AB890X", + "08342": "AB890X", + "08343": "AB890X", + "08344": "AB890X", + "08345": "AB890X", + "08346": "AB890X", + "08347": "AB890X", + "08348": "AB890X", + "08349": "AB890X", + "08350": "AB890X", + "08352": "AB890X", + "08353": "AB890X", + "08360": "AB890X", + "08361": "AB890X", + "08362": "AB890X", + "08401": "AB890X", + "08402": "AB890X", + "08403": "AB890X", + "08404": "AB890X", + "08405": "AB890X", + "08406": "AB890X", + "08501": "AB890X", + "08502": "AB890X", + "08504": "AB890X", + "08505": "AB890X", + "08510": "AB890X", + "08511": "AB890X", + "08512": "AB890X", + "08514": "AB890X", + "08515": "AB890X", + "08518": "AB890X", + "08520": "AB890X", + "08525": "AB890X", + "08526": "AB890X", + "08527": "AB890X", + "08528": "AB890X", + "08530": "AB890X", + "08533": "AB890X", + "08534": "AB890X", + "08535": "AB890X", + "08536": "AB890X", + "08540": "AB890X", + "08541": "AB890X", + "08542": "AB890X", + "08543": "AB890X", + "08544": "AB890X", + "08550": "AB890X", + "08551": "AB890X", + "08553": "AB890X", + "08554": "AB890X", + "08555": "AB890X", + "08556": "AB890X", + "08557": "AB890X", + "08558": "AB890X", + "08559": "AB890X", + "08560": "AB890X", + "08561": "AB890X", + "08562": "AB890X", + "08601": "AB890X", + "08602": "AB890X", + "08603": "AB890X", + "08604": "AB890X", + "08605": "AB890X", + "08606": "AB890X", + "08607": "AB890X", + "08608": "AB890X", + "08609": "AB890X", + "08610": "AB890X", + "08611": "AB890X", + "08618": "AB890X", + "08619": "AB890X", + "08620": "AB890X", + "08625": "AB890X", + "08628": "AB890X", + "08629": "AB890X", + "08638": "AB890X", + "08640": "AB890X", + "08641": "AB890X", + "08645": "AB890X", + "08646": "AB890X", + "08647": "AB890X", + "08648": "AB890X", + "08650": "AB890X", + "08666": "AB890X", + "08677": "AB890X", + "08690": "AB890X", + "08691": "AB890X", + "08695": "AB890X", + "08701": "AB890X", + "08720": "AB890X", + "08721": "AB890X", + "08722": "AB890X", + "08723": "AB890X", + "08724": "AB890X", + "08730": "AB890X", + "08731": "AB890X", + "08732": "AB890X", + "08733": "AB890X", + "08734": "AB890X", + "08735": "AB890X", + "08736": "AB890X", + "08738": "AB890X", + "08739": "AB890X", + "08740": "AB890X", + "08741": "AB890X", + "08742": "AB890X", + "08750": "AB890X", + "08751": "AB890X", + "08752": "AB890X", + "08753": "AB890X", + "08754": "AB890X", + "08755": "AB890X", + "08756": "AB890X", + "08757": "AB890X", + "08758": "AB890X", + "08759": "AB890X", + "08801": "AB890X", + "08802": "AB890X", + "08803": "AB890X", + "08804": "AB890X", + "08805": "AB890X", + "08807": "AB890X", + "08808": "AB890X", + "08809": "AB890X", + "08810": "AB890X", + "08812": "AB890X", + "08816": "AB890X", + "08817": "AB890X", + "08818": "AB890X", + "08820": "AB890X", + "08821": "AB890X", + "08822": "AB890X", + "08823": "AB890X", + "08824": "AB890X", + "08825": "AB890X", + "08826": "AB890X", + "08827": "AB890X", + "08828": "AB890X", + "08829": "AB890X", + "08830": "AB890X", + "08831": "AB890X", + "08832": "AB890X", + "08833": "AB890X", + "08834": "AB890X", + "08835": "AB890X", + "08836": "AB890X", + "08837": "AB890X", + "08840": "AB890X", + "08844": "AB890X", + "08846": "AB890X", + "08848": "AB890X", + "08850": "AB890X", + "08852": "AB890X", + "08853": "AB890X", + "08854": "AB890X", + "08855": "AB890X", + "08857": "AB890X", + "08858": "AB890X", + "08859": "AB890X", + "08861": "AB890X", + "08862": "AB890X", + "08863": "AB890X", + "08865": "AB890X", + "08867": "AB890X", + "08868": "AB890X", + "08869": "AB890X", + "08870": "AB890X", + "08871": "AB890X", + "08872": "AB890X", + "08873": "AB890X", + "08875": "AB890X", + "08876": "AB890X", + "08879": "AB890X", + "08880": "AB890X", + "08882": "AB890X", + "08884": "AB890X", + "08885": "AB890X", + "08886": "AB890X", + "08887": "AB890X", + "08888": "AB890X", + "08889": "AB890X", + "08890": "AB890X", + "08896": "AB890X", + "08899": "AB890X", + "08901": "AB890X", + "08902": "AB890X", + "08903": "AB890X", + "08904": "AB890X", + "08905": "AB890X", + "08906": "AB890X", + "08922": "AB890X", + "08933": "AB890X", + "08988": "AB890X", + "08989": "AB890X", + "10001": "AB890X", + "10002": "AB890X", + "10003": "AB890X", + "10004": "AB890X", + "10005": "AB890X", + "10006": "AB890X", + "10007": "AB890X", + "10008": "AB890X", + "10009": "AB890X", + "10010": "AB890X", + "10011": "AB890X", + "10012": "AB890X", + "10013": "AB890X", + "10014": "AB890X", + "10015": "AB890X", + "10016": "AB890X", + "10017": "AB890X", + "10018": "AB890X", + "10019": "AB890X", + "10020": "AB890X", + "10021": "AB890X", + "10022": "AB890X", + "10023": "AB890X", + "10024": "AB890X", + "10025": "AB890X", + "10026": "AB890X", + "10027": "AB890X", + "10028": "AB890X", + "10029": "AB890X", + "10030": "AB890X", + "10031": "AB890X", + "10032": "AB890X", + "10033": "AB890X", + "10034": "AB890X", + "10035": "AB890X", + "10036": "AB890X", + "10037": "AB890X", + "10038": "AB890X", + "10039": "AB890X", + "10040": "AB890X", + "10041": "AB890X", + "10043": "AB890X", + "10044": "AB890X", + "10045": "AB890X", + "10046": "AB890X", + "10047": "AB890X", + "10048": "AB890X", + "10055": "AB890X", + "10060": "AB890X", + "10069": "AB890X", + "10072": "AB890X", + "10079": "AB890X", + "10080": "AB890X", + "10081": "AB890X", + "10082": "AB890X", + "10087": "AB890X", + "10090": "AB890X", + "10094": "AB890X", + "10095": "AB890X", + "10096": "AB890X", + "10098": "AB890X", + "10099": "AB890X", + "10101": "AB890X", + "10102": "AB890X", + "10103": "AB890X", + "10104": "AB890X", + "10105": "AB890X", + "10106": "AB890X", + "10107": "AB890X", + "10108": "AB890X", + "10109": "AB890X", + "10110": "AB890X", + "10111": "AB890X", + "10112": "AB890X", + "10113": "AB890X", + "10114": "AB890X", + "10115": "AB890X", + "10116": "AB890X", + "10117": "AB890X", + "10118": "AB890X", + "10119": "AB890X", + "10120": "AB890X", + "10121": "AB890X", + "10122": "AB890X", + "10123": "AB890X", + "10124": "AB890X", + "10125": "AB890X", + "10126": "AB890X", + "10128": "AB890X", + "10129": "AB890X", + "10130": "AB890X", + "10131": "AB890X", + "10132": "AB890X", + "10133": "AB890X", + "10138": "AB890X", + "10149": "AB890X", + "10150": "AB890X", + "10151": "AB890X", + "10152": "AB890X", + "10153": "AB890X", + "10154": "AB890X", + "10155": "AB890X", + "10156": "AB890X", + "10157": "AB890X", + "10158": "AB890X", + "10159": "AB890X", + "10160": "AB890X", + "10161": "AB890X", + "10162": "AB890X", + "10163": "AB890X", + "10164": "AB890X", + "10165": "AB890X", + "10166": "AB890X", + "10167": "AB890X", + "10168": "AB890X", + "10169": "AB890X", + "10170": "AB890X", + "10171": "AB890X", + "10172": "AB890X", + "10173": "AB890X", + "10174": "AB890X", + "10175": "AB890X", + "10176": "AB890X", + "10177": "AB890X", + "10178": "AB890X", + "10179": "AB890X", + "10184": "AB890X", + "10185": "AB890X", + "10196": "AB890X", + "10197": "AB890X", + "10199": "AB890X", + "10203": "AB890X", + "10211": "AB890X", + "10212": "AB890X", + "10213": "AB890X", + "10242": "AB890X", + "10249": "AB890X", + "10256": "AB890X", + "10257": "AB890X", + "10258": "AB890X", + "10259": "AB890X", + "10260": "AB890X", + "10261": "AB890X", + "10265": "AB890X", + "10268": "AB890X", + "10269": "AB890X", + "10270": "AB890X", + "10271": "AB890X", + "10272": "AB890X", + "10273": "AB890X", + "10274": "AB890X", + "10275": "AB890X", + "10276": "AB890X", + "10277": "AB890X", + "10278": "AB890X", + "10279": "AB890X", + "10280": "AB890X", + "10281": "AB890X", + "10282": "AB890X", + "10285": "AB890X", + "10286": "AB890X", + "10292": "AB890X", + "10301": "AB890X", + "10302": "AB890X", + "10303": "AB890X", + "10304": "AB890X", + "10305": "AB890X", + "10306": "AB890X", + "10307": "AB890X", + "10308": "AB890X", + "10309": "AB890X", + "10310": "AB890X", + "10311": "AB890X", + "10312": "AB890X", + "10313": "AB890X", + "10314": "AB890X", + "10451": "AB890X", + "10452": "AB890X", + "10453": "AB890X", + "10454": "AB890X", + "10455": "AB890X", + "10456": "AB890X", + "10457": "AB890X", + "10458": "AB890X", + "10459": "AB890X", + "10460": "AB890X", + "10461": "AB890X", + "10462": "AB890X", + "10463": "AB890X", + "10464": "AB890X", + "10465": "AB890X", + "10466": "AB890X", + "10467": "AB890X", + "10468": "AB890X", + "10469": "AB890X", + "10470": "AB890X", + "10471": "AB890X", + "10472": "AB890X", + "10473": "AB890X", + "10474": "AB890X", + "10475": "AB890X", + "10499": "AB890X", + "10501": "AB890X", + "10502": "AB890X", + "10503": "AB890X", + "10504": "AB890X", + "10505": "AB890X", + "10506": "AB890X", + "10507": "AB890X", + "10509": "AB890X", + "10510": "AB890X", + "10511": "AB890X", + "10512": "AB890X", + "10514": "AB890X", + "10516": "AB890X", + "10517": "AB890X", + "10518": "AB890X", + "10519": "AB890X", + "10520": "AB890X", + "10521": "AB890X", + "10522": "AB890X", + "10523": "AB890X", + "10524": "AB890X", + "10526": "AB890X", + "10527": "AB890X", + "10528": "AB890X", + "10530": "AB890X", + "10532": "AB890X", + "10533": "AB890X", + "10535": "AB890X", + "10536": "AB890X", + "10537": "AB890X", + "10538": "AB890X", + "10540": "AB890X", + "10541": "AB890X", + "10542": "AB890X", + "10543": "AB890X", + "10545": "AB890X", + "10546": "AB890X", + "10547": "AB890X", + "10548": "AB890X", + "10549": "AB890X", + "10550": "AB890X", + "10551": "AB890X", + "10552": "AB890X", + "10553": "AB890X", + "10557": "AB890X", + "10558": "AB890X", + "10560": "AB890X", + "10562": "AB890X", + "10566": "AB890X", + "10567": "AB890X", + "10570": "AB890X", + "10571": "AB890X", + "10572": "AB890X", + "10573": "AB890X", + "10576": "AB890X", + "10577": "AB890X", + "10578": "AB890X", + "10579": "AB890X", + "10580": "AB890X", + "10583": "AB890X", + "10587": "AB890X", + "10588": "AB890X", + "10589": "AB890X", + "10590": "AB890X", + "10591": "AB890X", + "10594": "AB890X", + "10595": "AB890X", + "10596": "AB890X", + "10597": "AB890X", + "10598": "AB890X", + "10601": "AB890X", + "10602": "AB890X", + "10603": "AB890X", + "10604": "AB890X", + "10605": "AB890X", + "10606": "AB890X", + "10607": "AB890X", + "10610": "AB890X", + "10701": "AB890X", + "10702": "AB890X", + "10703": "AB890X", + "10704": "AB890X", + "10705": "AB890X", + "10706": "AB890X", + "10707": "AB890X", + "10708": "AB890X", + "10709": "AB890X", + "10710": "AB890X", + "10801": "AB890X", + "10802": "AB890X", + "10803": "AB890X", + "10804": "AB890X", + "10805": "AB890X", + "10901": "AB890X", + "10910": "AB890X", + "10911": "AB890X", + "10912": "AB890X", + "10913": "AB890X", + "10914": "AB890X", + "10915": "AB890X", + "10916": "AB890X", + "10917": "AB890X", + "10918": "AB890X", + "10919": "AB890X", + "10920": "AB890X", + "10921": "AB890X", + "10922": "AB890X", + "10923": "AB890X", + "10924": "AB890X", + "10925": "AB890X", + "10926": "AB890X", + "10927": "AB890X", + "10928": "AB890X", + "10930": "AB890X", + "10931": "AB890X", + "10932": "AB890X", + "10933": "AB890X", + "10940": "AB890X", + "10941": "AB890X", + "10943": "AB890X", + "10949": "AB890X", + "10950": "AB890X", + "10952": "AB890X", + "10953": "AB890X", + "10954": "AB890X", + "10956": "AB890X", + "10958": "AB890X", + "10959": "AB890X", + "10960": "AB890X", + "10962": "AB890X", + "10963": "AB890X", + "10964": "AB890X", + "10965": "AB890X", + "10968": "AB890X", + "10969": "AB890X", + "10970": "AB890X", + "10973": "AB890X", + "10974": "AB890X", + "10975": "AB890X", + "10976": "AB890X", + "10977": "AB890X", + "10979": "AB890X", + "10980": "AB890X", + "10981": "AB890X", + "10982": "AB890X", + "10983": "AB890X", + "10984": "AB890X", + "10985": "AB890X", + "10986": "AB890X", + "10987": "AB890X", + "10988": "AB890X", + "10989": "AB890X", + "10990": "AB890X", + "10992": "AB890X", + "10993": "AB890X", + "10994": "AB890X", + "10996": "AB890X", + "10997": "AB890X", + "10998": "AB890X", + "11001": "AB890X", + "11002": "AB890X", + "11003": "AB890X", + "11004": "AB890X", + "11005": "AB890X", + "11010": "AB890X", + "11020": "AB890X", + "11021": "AB890X", + "11022": "AB890X", + "11023": "AB890X", + "11024": "AB890X", + "11025": "AB890X", + "11026": "AB890X", + "11027": "AB890X", + "11030": "AB890X", + "11040": "AB890X", + "11041": "AB890X", + "11042": "AB890X", + "11043": "AB890X", + "11044": "AB890X", + "11050": "AB890X", + "11051": "AB890X", + "11052": "AB890X", + "11053": "AB890X", + "11054": "AB890X", + "11055": "AB890X", + "11096": "AB890X", + "11099": "AB890X", + "11101": "AB890X", + "11102": "AB890X", + "11103": "AB890X", + "11104": "AB890X", + "11105": "AB890X", + "11106": "AB890X", + "11109": "AB890X", + "11120": "AB890X", + "11201": "AB890X", + "11202": "AB890X", + "11203": "AB890X", + "11204": "AB890X", + "11205": "AB890X", + "11206": "AB890X", + "11207": "AB890X", + "11208": "AB890X", + "11209": "AB890X", + "11210": "AB890X", + "11211": "AB890X", + "11212": "AB890X", + "11213": "AB890X", + "11214": "AB890X", + "11215": "AB890X", + "11216": "AB890X", + "11217": "AB890X", + "11218": "AB890X", + "11219": "AB890X", + "11220": "AB890X", + "11221": "AB890X", + "11222": "AB890X", + "11223": "AB890X", + "11224": "AB890X", + "11225": "AB890X", + "11226": "AB890X", + "11228": "AB890X", + "11229": "AB890X", + "11230": "AB890X", + "11231": "AB890X", + "11232": "AB890X", + "11233": "AB890X", + "11234": "AB890X", + "11235": "AB890X", + "11236": "AB890X", + "11237": "AB890X", + "11238": "AB890X", + "11239": "AB890X", + "11240": "AB890X", + "11241": "AB890X", + "11242": "AB890X", + "11243": "AB890X", + "11244": "AB890X", + "11245": "AB890X", + "11247": "AB890X", + "11248": "AB890X", + "11249": "AB890X", + "11251": "AB890X", + "11252": "AB890X", + "11254": "AB890X", + "11255": "AB890X", + "11256": "AB890X", + "11351": "AB890X", + "11352": "AB890X", + "11354": "AB890X", + "11355": "AB890X", + "11356": "AB890X", + "11357": "AB890X", + "11358": "AB890X", + "11359": "AB890X", + "11360": "AB890X", + "11361": "AB890X", + "11362": "AB890X", + "11363": "AB890X", + "11364": "AB890X", + "11365": "AB890X", + "11366": "AB890X", + "11367": "AB890X", + "11368": "AB890X", + "11369": "AB890X", + "11370": "AB890X", + "11371": "AB890X", + "11372": "AB890X", + "11373": "AB890X", + "11374": "AB890X", + "11375": "AB890X", + "11377": "AB890X", + "11378": "AB890X", + "11379": "AB890X", + "11380": "AB890X", + "11381": "AB890X", + "11385": "AB890X", + "11386": "AB890X", + "11390": "AB890X", + "11405": "AB890X", + "11411": "AB890X", + "11412": "AB890X", + "11413": "AB890X", + "11414": "AB890X", + "11415": "AB890X", + "11416": "AB890X", + "11417": "AB890X", + "11418": "AB890X", + "11419": "AB890X", + "11420": "AB890X", + "11421": "AB890X", + "11422": "AB890X", + "11423": "AB890X", + "11424": "AB890X", + "11425": "AB890X", + "11426": "AB890X", + "11427": "AB890X", + "11428": "AB890X", + "11429": "AB890X", + "11430": "AB890X", + "11431": "AB890X", + "11432": "AB890X", + "11433": "AB890X", + "11434": "AB890X", + "11435": "AB890X", + "11436": "AB890X", + "11439": "AB890X", + "11451": "AB890X", + "11499": "AB890X", + "11501": "AB890X", + "11507": "AB890X", + "11509": "AB890X", + "11510": "AB890X", + "11514": "AB890X", + "11516": "AB890X", + "11518": "AB890X", + "11520": "AB890X", + "11530": "AB890X", + "11531": "AB890X", + "11535": "AB890X", + "11536": "AB890X", + "11542": "AB890X", + "11545": "AB890X", + "11547": "AB890X", + "11548": "AB890X", + "11549": "AB890X", + "11550": "AB890X", + "11551": "AB890X", + "11552": "AB890X", + "11553": "AB890X", + "11554": "AB890X", + "11555": "AB890X", + "11556": "AB890X", + "11557": "AB890X", + "11558": "AB890X", + "11559": "AB890X", + "11560": "AB890X", + "11561": "AB890X", + "11563": "AB890X", + "11565": "AB890X", + "11566": "AB890X", + "11568": "AB890X", + "11569": "AB890X", + "11570": "AB890X", + "11571": "AB890X", + "11572": "AB890X", + "11575": "AB890X", + "11576": "AB890X", + "11577": "AB890X", + "11579": "AB890X", + "11580": "AB890X", + "11581": "AB890X", + "11582": "AB890X", + "11590": "AB890X", + "11592": "AB890X", + "11594": "AB890X", + "11595": "AB890X", + "11596": "AB890X", + "11597": "AB890X", + "11598": "AB890X", + "11599": "AB890X", + "11690": "AB890X", + "11691": "AB890X", + "11692": "AB890X", + "11693": "AB890X", + "11694": "AB890X", + "11695": "AB890X", + "11697": "AB890X", + "11701": "AB890X", + "11702": "AB890X", + "11703": "AB890X", + "11704": "AB890X", + "11705": "AB890X", + "11706": "AB890X", + "11707": "AB890X", + "11708": "AB890X", + "11709": "AB890X", + "11710": "AB890X", + "11713": "AB890X", + "11714": "AB890X", + "11715": "AB890X", + "11716": "AB890X", + "11717": "AB890X", + "11718": "AB890X", + "11719": "AB890X", + "11720": "AB890X", + "11721": "AB890X", + "11722": "AB890X", + "11724": "AB890X", + "11725": "AB890X", + "11726": "AB890X", + "11727": "AB890X", + "11729": "AB890X", + "11730": "AB890X", + "11731": "AB890X", + "11732": "AB890X", + "11733": "AB890X", + "11735": "AB890X", + "11736": "AB890X", + "11737": "AB890X", + "11738": "AB890X", + "11739": "AB890X", + "11740": "AB890X", + "11741": "AB890X", + "11742": "AB890X", + "11743": "AB890X", + "11746": "AB890X", + "11747": "AB890X", + "11749": "AB890X", + "11750": "AB890X", + "11751": "AB890X", + "11752": "AB890X", + "11753": "AB890X", + "11754": "AB890X", + "11755": "AB890X", + "11756": "AB890X", + "11757": "AB890X", + "11758": "AB890X", + "11760": "AB890X", + "11762": "AB890X", + "11763": "AB890X", + "11764": "AB890X", + "11765": "AB890X", + "11766": "AB890X", + "11767": "AB890X", + "11768": "AB890X", + "11769": "AB890X", + "11770": "AB890X", + "11771": "AB890X", + "11772": "AB890X", + "11773": "AB890X", + "11774": "AB890X", + "11775": "AB890X", + "11776": "AB890X", + "11777": "AB890X", + "11778": "AB890X", + "11779": "AB890X", + "11780": "AB890X", + "11782": "AB890X", + "11783": "AB890X", + "11784": "AB890X", + "11786": "AB890X", + "11787": "AB890X", + "11788": "AB890X", + "11789": "AB890X", + "11790": "AB890X", + "11791": "AB890X", + "11792": "AB890X", + "11793": "AB890X", + "11794": "AB890X", + "11795": "AB890X", + "11796": "AB890X", + "11797": "AB890X", + "11798": "AB890X", + "11801": "AB890X", + "11802": "AB890X", + "11803": "AB890X", + "11804": "AB890X", + "11815": "AB890X", + "11819": "AB890X", + "11853": "AB890X", + "11854": "AB890X", + "11855": "AB890X", + "11901": "AB890X", + "11930": "AB890X", + "11931": "AB890X", + "11932": "AB890X", + "11933": "AB890X", + "11934": "AB890X", + "11935": "AB890X", + "11937": "AB890X", + "11939": "AB890X", + "11940": "AB890X", + "11941": "AB890X", + "11942": "AB890X", + "11944": "AB890X", + "11946": "AB890X", + "11947": "AB890X", + "11948": "AB890X", + "11949": "AB890X", + "11950": "AB890X", + "11951": "AB890X", + "11952": "AB890X", + "11953": "AB890X", + "11954": "AB890X", + "11955": "AB890X", + "11956": "AB890X", + "11957": "AB890X", + "11958": "AB890X", + "11959": "AB890X", + "11960": "AB890X", + "11961": "AB890X", + "11962": "AB890X", + "11963": "AB890X", + "11964": "AB890X", + "11965": "AB890X", + "11967": "AB890X", + "11968": "AB890X", + "11969": "AB890X", + "11970": "AB890X", + "11971": "AB890X", + "11972": "AB890X", + "11973": "AB890X", + "11975": "AB890X", + "11976": "AB890X", + "11977": "AB890X", + "11978": "AB890X", + "11980": "AB890X", + "12007": "AB890X", + "12008": "AB890X", + "12009": "AB890X", + "12010": "AB890X", + "12015": "AB890X", + "12016": "AB890X", + "12017": "AB890X", + "12018": "AB890X", + "12019": "AB890X", + "12020": "AB890X", + "12022": "AB890X", + "12023": "AB890X", + "12024": "AB890X", + "12025": "AB890X", + "12027": "AB890X", + "12028": "AB890X", + "12029": "AB890X", + "12031": "AB890X", + "12032": "AB890X", + "12033": "AB890X", + "12035": "AB890X", + "12036": "AB890X", + "12037": "AB890X", + "12040": "AB890X", + "12041": "AB890X", + "12042": "AB890X", + "12043": "AB890X", + "12045": "AB890X", + "12046": "AB890X", + "12047": "AB890X", + "12050": "AB890X", + "12051": "AB890X", + "12052": "AB890X", + "12053": "AB890X", + "12054": "AB890X", + "12055": "AB890X", + "12056": "AB890X", + "12057": "AB890X", + "12058": "AB890X", + "12059": "AB890X", + "12060": "AB890X", + "12061": "AB890X", + "12062": "AB890X", + "12063": "AB890X", + "12064": "AB900X", + "12065": "AB890X", + "12066": "AB890X", + "12067": "AB890X", + "12068": "AB890X", + "12069": "AB890X", + "12070": "AB890X", + "12071": "AB890X", + "12072": "AB890X", + "12073": "AB890X", + "12074": "AB890X", + "12075": "AB890X", + "12076": "AB890X", + "12077": "AB890X", + "12078": "AB890X", + "12082": "AB890X", + "12083": "AB890X", + "12084": "AB890X", + "12085": "AB890X", + "12086": "AB890X", + "12087": "AB890X", + "12089": "AB890X", + "12090": "AB890X", + "12092": "AB890X", + "12093": "AB900X", + "12094": "AB890X", + "12095": "AB890X", + "12106": "AB890X", + "12107": "AB890X", + "12108": "AB890X", + "12110": "AB890X", + "12115": "AB890X", + "12116": "AB900X", + "12117": "AB890X", + "12118": "AB890X", + "12120": "AB890X", + "12121": "AB890X", + "12122": "AB890X", + "12123": "AB890X", + "12124": "AB890X", + "12125": "AB890X", + "12128": "AB890X", + "12130": "AB890X", + "12131": "AB890X", + "12132": "AB890X", + "12133": "AB890X", + "12134": "AB890X", + "12136": "AB890X", + "12137": "AB890X", + "12138": "AB890X", + "12139": "AB900X", + "12140": "AB890X", + "12141": "AB890X", + "12143": "AB890X", + "12144": "AB890X", + "12147": "AB890X", + "12148": "AB890X", + "12149": "AB890X", + "12150": "AB890X", + "12151": "AB890X", + "12153": "AB890X", + "12154": "AB890X", + "12155": "AB900X", + "12156": "AB890X", + "12157": "AB890X", + "12158": "AB890X", + "12159": "AB890X", + "12160": "AB890X", + "12161": "AB890X", + "12164": "AB890X", + "12165": "AB890X", + "12166": "AB890X", + "12167": "AB900X", + "12168": "AB890X", + "12169": "AB890X", + "12170": "AB890X", + "12172": "AB890X", + "12173": "AB890X", + "12174": "AB890X", + "12175": "AB890X", + "12176": "AB890X", + "12177": "AB890X", + "12180": "AB890X", + "12181": "AB890X", + "12182": "AB890X", + "12183": "AB890X", + "12184": "AB890X", + "12185": "AB890X", + "12186": "AB890X", + "12187": "AB890X", + "12188": "AB890X", + "12189": "AB890X", + "12190": "AB890X", + "12192": "AB890X", + "12193": "AB890X", + "12194": "AB890X", + "12195": "AB890X", + "12196": "AB890X", + "12197": "AB900X", + "12198": "AB890X", + "12201": "AB890X", + "12202": "AB890X", + "12203": "AB890X", + "12204": "AB890X", + "12205": "AB890X", + "12206": "AB890X", + "12207": "AB890X", + "12208": "AB890X", + "12209": "AB890X", + "12210": "AB890X", + "12211": "AB890X", + "12212": "AB890X", + "12214": "AB890X", + "12220": "AB890X", + "12222": "AB890X", + "12223": "AB890X", + "12224": "AB890X", + "12225": "AB890X", + "12226": "AB890X", + "12227": "AB890X", + "12228": "AB890X", + "12229": "AB890X", + "12230": "AB890X", + "12231": "AB890X", + "12232": "AB890X", + "12233": "AB890X", + "12234": "AB890X", + "12235": "AB890X", + "12236": "AB890X", + "12237": "AB890X", + "12238": "AB890X", + "12239": "AB890X", + "12240": "AB890X", + "12241": "AB890X", + "12242": "AB890X", + "12243": "AB890X", + "12244": "AB890X", + "12245": "AB890X", + "12246": "AB890X", + "12247": "AB890X", + "12248": "AB890X", + "12249": "AB890X", + "12250": "AB890X", + "12252": "AB890X", + "12255": "AB890X", + "12256": "AB890X", + "12257": "AB890X", + "12260": "AB890X", + "12261": "AB890X", + "12288": "AB890X", + "12301": "AB890X", + "12302": "AB890X", + "12303": "AB890X", + "12304": "AB890X", + "12305": "AB890X", + "12306": "AB890X", + "12307": "AB890X", + "12308": "AB890X", + "12309": "AB890X", + "12325": "AB890X", + "12345": "AB890X", + "12401": "AB890X", + "12402": "AB890X", + "12404": "AB890X", + "12405": "AB890X", + "12406": "AB900X", + "12407": "AB890X", + "12409": "AB890X", + "12410": "AB890X", + "12411": "AB890X", + "12412": "AB890X", + "12413": "AB890X", + "12414": "AB890X", + "12416": "AB890X", + "12417": "AB890X", + "12418": "AB890X", + "12419": "AB890X", + "12420": "AB890X", + "12421": "AB900X", + "12422": "AB890X", + "12423": "AB890X", + "12424": "AB890X", + "12427": "AB890X", + "12428": "AB890X", + "12429": "AB890X", + "12430": "AB900X", + "12431": "AB890X", + "12432": "AB890X", + "12433": "AB890X", + "12434": "AB900X", + "12435": "AB890X", + "12436": "AB890X", + "12438": "AB900X", + "12439": "AB890X", + "12440": "AB890X", + "12441": "AB890X", + "12442": "AB890X", + "12443": "AB890X", + "12444": "AB890X", + "12446": "AB890X", + "12448": "AB890X", + "12449": "AB890X", + "12450": "AB890X", + "12451": "AB890X", + "12452": "AB890X", + "12453": "AB890X", + "12454": "AB890X", + "12455": "AB900X", + "12456": "AB890X", + "12457": "AB890X", + "12458": "AB890X", + "12459": "AB900X", + "12460": "AB890X", + "12461": "AB890X", + "12463": "AB890X", + "12464": "AB890X", + "12465": "AB890X", + "12466": "AB890X", + "12468": "AB900X", + "12469": "AB890X", + "12470": "AB890X", + "12471": "AB890X", + "12472": "AB890X", + "12473": "AB890X", + "12474": "AB900X", + "12475": "AB890X", + "12477": "AB890X", + "12480": "AB890X", + "12481": "AB890X", + "12482": "AB890X", + "12483": "AB890X", + "12484": "AB890X", + "12485": "AB890X", + "12486": "AB890X", + "12487": "AB890X", + "12489": "AB890X", + "12490": "AB890X", + "12491": "AB890X", + "12492": "AB890X", + "12493": "AB890X", + "12494": "AB890X", + "12495": "AB890X", + "12496": "AB890X", + "12498": "AB890X", + "12501": "AB890X", + "12502": "AB890X", + "12503": "AB890X", + "12504": "AB890X", + "12506": "AB890X", + "12507": "AB890X", + "12508": "AB890X", + "12510": "AB890X", + "12511": "AB890X", + "12512": "AB890X", + "12513": "AB890X", + "12514": "AB890X", + "12515": "AB890X", + "12516": "AB890X", + "12517": "AB890X", + "12518": "AB890X", + "12520": "AB890X", + "12521": "AB890X", + "12522": "AB890X", + "12523": "AB890X", + "12524": "AB890X", + "12525": "AB890X", + "12526": "AB890X", + "12527": "AB890X", + "12528": "AB890X", + "12529": "AB890X", + "12530": "AB890X", + "12531": "AB890X", + "12533": "AB890X", + "12534": "AB890X", + "12537": "AB890X", + "12538": "AB890X", + "12540": "AB890X", + "12541": "AB890X", + "12542": "AB890X", + "12543": "AB890X", + "12544": "AB890X", + "12545": "AB890X", + "12546": "AB890X", + "12547": "AB890X", + "12548": "AB890X", + "12549": "AB890X", + "12550": "AB890X", + "12551": "AB890X", + "12552": "AB890X", + "12553": "AB890X", + "12555": "AB890X", + "12561": "AB890X", + "12563": "AB890X", + "12564": "AB890X", + "12565": "AB890X", + "12566": "AB890X", + "12567": "AB890X", + "12568": "AB890X", + "12569": "AB890X", + "12570": "AB890X", + "12571": "AB890X", + "12572": "AB890X", + "12574": "AB890X", + "12575": "AB890X", + "12577": "AB890X", + "12578": "AB890X", + "12580": "AB890X", + "12581": "AB890X", + "12582": "AB890X", + "12583": "AB890X", + "12584": "AB890X", + "12585": "AB890X", + "12586": "AB890X", + "12588": "AB890X", + "12589": "AB890X", + "12590": "AB890X", + "12592": "AB890X", + "12593": "AB890X", + "12594": "AB890X", + "12601": "AB890X", + "12602": "AB890X", + "12603": "AB890X", + "12604": "AB890X", + "12701": "AB890X", + "12719": "AB890X", + "12720": "AB890X", + "12721": "AB890X", + "12722": "AB890X", + "12723": "AB890X", + "12724": "AB890X", + "12725": "AB890X", + "12726": "AB890X", + "12727": "AB890X", + "12729": "AB890X", + "12732": "AB890X", + "12733": "AB890X", + "12734": "AB890X", + "12736": "AB890X", + "12737": "AB890X", + "12738": "AB890X", + "12740": "AB890X", + "12741": "AB890X", + "12742": "AB890X", + "12743": "AB890X", + "12745": "AB890X", + "12746": "AB890X", + "12747": "AB890X", + "12748": "AB890X", + "12749": "AB890X", + "12750": "AB890X", + "12751": "AB890X", + "12752": "AB890X", + "12754": "AB890X", + "12758": "AB890X", + "12759": "AB890X", + "12760": "AB890X", + "12762": "AB890X", + "12763": "AB890X", + "12764": "AB890X", + "12765": "AB890X", + "12766": "AB890X", + "12767": "AB890X", + "12768": "AB890X", + "12769": "AB890X", + "12770": "AB890X", + "12771": "AB890X", + "12775": "AB890X", + "12776": "AB890X", + "12777": "AB890X", + "12778": "AB890X", + "12779": "AB890X", + "12780": "AB890X", + "12781": "AB890X", + "12783": "AB890X", + "12784": "AB890X", + "12785": "AB890X", + "12786": "AB890X", + "12787": "AB890X", + "12788": "AB890X", + "12789": "AB890X", + "12790": "AB890X", + "12791": "AB890X", + "12792": "AB890X", + "12801": "AB890X", + "12803": "AB890X", + "12804": "AB890X", + "12808": "AB890X", + "12809": "AB890X", + "12810": "AB890X", + "12811": "AB890X", + "12812": "AB890X", + "12814": "AB890X", + "12815": "AB890X", + "12816": "AB890X", + "12817": "AB890X", + "12819": "AB890X", + "12820": "AB890X", + "12821": "AB890X", + "12822": "AB890X", + "12823": "AB890X", + "12824": "AB890X", + "12827": "AB890X", + "12828": "AB890X", + "12831": "AB890X", + "12832": "AB890X", + "12833": "AB890X", + "12834": "AB890X", + "12835": "AB890X", + "12836": "AB890X", + "12837": "AB890X", + "12838": "AB890X", + "12839": "AB890X", + "12841": "AB890X", + "12842": "AB890X", + "12843": "AB890X", + "12844": "AB890X", + "12845": "AB890X", + "12846": "AB890X", + "12847": "AB890X", + "12848": "AB890X", + "12849": "AB890X", + "12850": "AB890X", + "12851": "AB890X", + "12852": "AB890X", + "12853": "AB890X", + "12854": "AB890X", + "12855": "AB889X", + "12856": "AB890X", + "12857": "AB890X", + "12858": "AB889X", + "12859": "AB890X", + "12860": "AB890X", + "12861": "AB890X", + "12862": "AB890X", + "12863": "AB890X", + "12864": "AB890X", + "12865": "AB890X", + "12866": "AB890X", + "12870": "AB889X", + "12871": "AB890X", + "12872": "AB889X", + "12873": "AB890X", + "12874": "AB890X", + "12878": "AB890X", + "12879": "AB889X", + "12883": "AB889X", + "12884": "AB890X", + "12885": "AB890X", + "12886": "AB890X", + "12887": "AB890X", + "12901": "AB889X", + "12903": "AB889X", + "12910": "AB889X", + "12911": "AB889X", + "12912": "AB889X", + "12913": "AB889X", + "12914": "AB889X", + "12915": "AB889X", + "12916": "AB889X", + "12917": "AB889X", + "12918": "AB890X", + "12919": "AB889X", + "12920": "AB889X", + "12921": "AB889X", + "12922": "AB889X", + "12923": "AB889X", + "12924": "AB889X", + "12926": "AB889X", + "12927": "AB900X", + "12928": "AB889X", + "12929": "AB889X", + "12930": "AB889X", + "12932": "AB889X", + "12933": "AB889X", + "12934": "AB889X", + "12935": "AB889X", + "12936": "AB889X", + "12937": "AB889X", + "12939": "AB889X", + "12941": "AB889X", + "12942": "AB889X", + "12943": "AB889X", + "12944": "AB889X", + "12945": "AB889X", + "12946": "AB889X", + "12949": "AB889X", + "12950": "AB889X", + "12952": "AB889X", + "12953": "AB889X", + "12955": "AB889X", + "12956": "AB889X", + "12957": "AB889X", + "12958": "AB889X", + "12959": "AB889X", + "12960": "AB889X", + "12961": "AB889X", + "12962": "AB889X", + "12964": "AB889X", + "12965": "AB900X", + "12966": "AB889X", + "12967": "AB900X", + "12969": "AB889X", + "12970": "AB889X", + "12972": "AB889X", + "12973": "AB889X", + "12974": "AB889X", + "12975": "AB889X", + "12976": "AB889X", + "12977": "AB889X", + "12978": "AB889X", + "12979": "AB889X", + "12980": "AB889X", + "12981": "AB889X", + "12983": "AB889X", + "12985": "AB889X", + "12986": "AB900X", + "12987": "AB889X", + "12989": "AB889X", + "12992": "AB889X", + "12993": "AB889X", + "12995": "AB889X", + "12996": "AB889X", + "12997": "AB889X", + "12998": "AB889X", + "13020": "AB900X", + "13021": "AB900X", + "13022": "AB900X", + "13024": "AB900X", + "13026": "AB900X", + "13027": "AB900X", + "13028": "AB900X", + "13029": "AB900X", + "13030": "AB900X", + "13031": "AB900X", + "13032": "AB900X", + "13033": "AB900X", + "13034": "AB900X", + "13035": "AB900X", + "13036": "AB900X", + "13037": "AB900X", + "13039": "AB900X", + "13040": "AB890X", + "13041": "AB900X", + "13042": "AB900X", + "13043": "AB900X", + "13044": "AB900X", + "13045": "AB900X", + "13051": "AB900X", + "13052": "AB900X", + "13053": "AB900X", + "13054": "AB900X", + "13056": "AB890X", + "13057": "AB900X", + "13060": "AB900X", + "13061": "AB900X", + "13062": "AB900X", + "13063": "AB900X", + "13064": "AB900X", + "13065": "AB900X", + "13066": "AB900X", + "13068": "AB900X", + "13069": "AB900X", + "13071": "AB900X", + "13072": "AB900X", + "13073": "AB900X", + "13074": "AB900X", + "13076": "AB900X", + "13077": "AB890X", + "13078": "AB900X", + "13080": "AB900X", + "13081": "AB900X", + "13082": "AB900X", + "13083": "AB900X", + "13084": "AB900X", + "13087": "AB890X", + "13088": "AB900X", + "13089": "AB900X", + "13090": "AB900X", + "13092": "AB900X", + "13093": "AB900X", + "13101": "AB890X", + "13102": "AB900X", + "13103": "AB900X", + "13104": "AB900X", + "13107": "AB900X", + "13108": "AB900X", + "13110": "AB900X", + "13111": "AB900X", + "13112": "AB900X", + "13113": "AB900X", + "13114": "AB900X", + "13115": "AB900X", + "13116": "AB900X", + "13117": "AB900X", + "13118": "AB900X", + "13119": "AB900X", + "13120": "AB900X", + "13121": "AB900X", + "13122": "AB900X", + "13123": "AB900X", + "13124": "AB900X", + "13126": "AB900X", + "13131": "AB900X", + "13132": "AB900X", + "13134": "AB900X", + "13135": "AB900X", + "13136": "AB900X", + "13137": "AB900X", + "13138": "AB900X", + "13139": "AB900X", + "13140": "AB900X", + "13141": "AB890X", + "13142": "AB900X", + "13143": "AB900X", + "13144": "AB900X", + "13145": "AB900X", + "13146": "AB900X", + "13147": "AB900X", + "13148": "AB900X", + "13152": "AB900X", + "13153": "AB900X", + "13154": "AB900X", + "13155": "AB900X", + "13156": "AB900X", + "13157": "AB900X", + "13158": "AB900X", + "13159": "AB900X", + "13160": "AB900X", + "13162": "AB900X", + "13163": "AB900X", + "13164": "AB900X", + "13165": "AB900X", + "13166": "AB900X", + "13167": "AB900X", + "13201": "AB900X", + "13202": "AB900X", + "13203": "AB900X", + "13204": "AB900X", + "13205": "AB900X", + "13206": "AB900X", + "13207": "AB900X", + "13208": "AB900X", + "13209": "AB900X", + "13210": "AB900X", + "13211": "AB900X", + "13212": "AB900X", + "13214": "AB900X", + "13215": "AB900X", + "13217": "AB900X", + "13218": "AB900X", + "13219": "AB900X", + "13220": "AB900X", + "13221": "AB900X", + "13224": "AB900X", + "13225": "AB900X", + "13235": "AB900X", + "13244": "AB900X", + "13250": "AB900X", + "13251": "AB900X", + "13252": "AB900X", + "13261": "AB900X", + "13290": "AB900X", + "13301": "AB900X", + "13302": "AB900X", + "13303": "AB900X", + "13304": "AB900X", + "13305": "AB900X", + "13308": "AB900X", + "13309": "AB900X", + "13310": "AB900X", + "13312": "AB900X", + "13313": "AB900X", + "13314": "AB900X", + "13315": "AB900X", + "13316": "AB900X", + "13317": "AB890X", + "13318": "AB900X", + "13319": "AB900X", + "13320": "AB900X", + "13321": "AB900X", + "13322": "AB900X", + "13323": "AB900X", + "13324": "AB900X", + "13325": "AB900X", + "13326": "AB900X", + "13327": "AB900X", + "13328": "AB900X", + "13329": "AB900X", + "13331": "AB900X", + "13332": "AB890X", + "13333": "AB900X", + "13334": "AB900X", + "13335": "AB900X", + "13337": "AB900X", + "13338": "AB900X", + "13339": "AB890X", + "13340": "AB900X", + "13341": "AB900X", + "13342": "AB900X", + "13343": "AB900X", + "13345": "AB900X", + "13346": "AB900X", + "13348": "AB900X", + "13350": "AB900X", + "13352": "AB900X", + "13353": "AB890X", + "13354": "AB900X", + "13355": "AB900X", + "13357": "AB900X", + "13360": "AB900X", + "13361": "AB900X", + "13362": "AB900X", + "13363": "AB900X", + "13364": "AB900X", + "13365": "AB900X", + "13367": "AB900X", + "13368": "AB900X", + "13401": "AB900X", + "13402": "AB900X", + "13403": "AB900X", + "13404": "AB900X", + "13406": "AB900X", + "13407": "AB900X", + "13408": "AB900X", + "13409": "AB900X", + "13410": "AB900X", + "13411": "AB900X", + "13413": "AB900X", + "13415": "AB900X", + "13416": "AB900X", + "13417": "AB900X", + "13418": "AB900X", + "13420": "AB900X", + "13421": "AB900X", + "13424": "AB900X", + "13425": "AB900X", + "13426": "AB900X", + "13428": "AB890X", + "13431": "AB900X", + "13433": "AB900X", + "13435": "AB900X", + "13436": "AB890X", + "13437": "AB900X", + "13438": "AB900X", + "13439": "AB900X", + "13440": "AB900X", + "13441": "AB900X", + "13442": "AB900X", + "13449": "AB900X", + "13450": "AB900X", + "13452": "AB890X", + "13454": "AB900X", + "13455": "AB900X", + "13456": "AB900X", + "13457": "AB900X", + "13459": "AB890X", + "13460": "AB890X", + "13461": "AB900X", + "13464": "AB890X", + "13465": "AB900X", + "13468": "AB900X", + "13469": "AB900X", + "13470": "AB900X", + "13471": "AB900X", + "13472": "AB900X", + "13473": "AB900X", + "13475": "AB900X", + "13476": "AB900X", + "13477": "AB900X", + "13478": "AB900X", + "13479": "AB900X", + "13480": "AB900X", + "13482": "AB900X", + "13483": "AB900X", + "13484": "AB900X", + "13485": "AB900X", + "13486": "AB900X", + "13488": "AB900X", + "13489": "AB900X", + "13490": "AB900X", + "13491": "AB900X", + "13492": "AB900X", + "13493": "AB900X", + "13494": "AB900X", + "13495": "AB900X", + "13501": "AB900X", + "13502": "AB900X", + "13503": "AB900X", + "13504": "AB900X", + "13505": "AB900X", + "13599": "AB900X", + "13601": "AB900X", + "13602": "AB900X", + "13603": "AB900X", + "13605": "AB900X", + "13606": "AB900X", + "13607": "AB900X", + "13608": "AB900X", + "13611": "AB900X", + "13612": "AB900X", + "13613": "AB900X", + "13614": "AB900X", + "13615": "AB900X", + "13616": "AB900X", + "13617": "AB900X", + "13618": "AB900X", + "13619": "AB900X", + "13620": "AB900X", + "13621": "AB900X", + "13622": "AB900X", + "13623": "AB900X", + "13624": "AB900X", + "13625": "AB900X", + "13626": "AB900X", + "13627": "AB900X", + "13628": "AB900X", + "13630": "AB900X", + "13631": "AB900X", + "13632": "AB900X", + "13633": "AB900X", + "13634": "AB900X", + "13635": "AB900X", + "13636": "AB900X", + "13637": "AB900X", + "13638": "AB900X", + "13639": "AB900X", + "13640": "AB900X", + "13641": "AB900X", + "13642": "AB900X", + "13643": "AB900X", + "13645": "AB900X", + "13646": "AB900X", + "13647": "AB900X", + "13648": "AB900X", + "13649": "AB900X", + "13650": "AB900X", + "13651": "AB900X", + "13652": "AB900X", + "13654": "AB900X", + "13655": "AB900X", + "13656": "AB900X", + "13657": "AB900X", + "13658": "AB900X", + "13659": "AB900X", + "13660": "AB900X", + "13661": "AB900X", + "13662": "AB900X", + "13664": "AB900X", + "13665": "AB900X", + "13666": "AB900X", + "13667": "AB900X", + "13668": "AB900X", + "13669": "AB900X", + "13670": "AB900X", + "13671": "AB900X", + "13672": "AB900X", + "13673": "AB900X", + "13674": "AB900X", + "13675": "AB900X", + "13676": "AB900X", + "13677": "AB900X", + "13678": "AB900X", + "13679": "AB900X", + "13680": "AB900X", + "13681": "AB900X", + "13682": "AB900X", + "13683": "AB900X", + "13684": "AB900X", + "13685": "AB900X", + "13687": "AB900X", + "13690": "AB900X", + "13691": "AB900X", + "13692": "AB900X", + "13693": "AB900X", + "13694": "AB900X", + "13695": "AB900X", + "13696": "AB900X", + "13697": "AB900X", + "13699": "AB900X", + "13730": "AB890X", + "13731": "AB900X", + "13732": "AB890X", + "13733": "AB890X", + "13734": "AB890X", + "13736": "AB890X", + "13737": "AB890X", + "13738": "AB890X", + "13739": "AB900X", + "13740": "AB900X", + "13743": "AB890X", + "13744": "AB890X", + "13745": "AB890X", + "13746": "AB890X", + "13747": "AB900X", + "13748": "AB890X", + "13749": "AB890X", + "13750": "AB900X", + "13751": "AB900X", + "13752": "AB900X", + "13753": "AB900X", + "13754": "AB890X", + "13755": "AB890X", + "13756": "AB890X", + "13757": "AB900X", + "13758": "AB890X", + "13760": "AB890X", + "13761": "AB890X", + "13762": "AB890X", + "13763": "AB890X", + "13774": "AB900X", + "13775": "AB900X", + "13776": "AB900X", + "13777": "AB890X", + "13778": "AB890X", + "13780": "AB890X", + "13782": "AB900X", + "13783": "AB890X", + "13784": "AB890X", + "13786": "AB900X", + "13787": "AB890X", + "13788": "AB900X", + "13790": "AB890X", + "13794": "AB890X", + "13795": "AB890X", + "13796": "AB900X", + "13797": "AB890X", + "13801": "AB890X", + "13802": "AB890X", + "13803": "AB890X", + "13804": "AB900X", + "13806": "AB900X", + "13807": "AB900X", + "13808": "AB900X", + "13809": "AB900X", + "13810": "AB900X", + "13811": "AB890X", + "13812": "AB890X", + "13813": "AB890X", + "13814": "AB890X", + "13815": "AB890X", + "13820": "AB900X", + "13825": "AB900X", + "13826": "AB890X", + "13827": "AB890X", + "13830": "AB890X", + "13832": "AB890X", + "13833": "AB890X", + "13834": "AB900X", + "13835": "AB890X", + "13837": "AB900X", + "13838": "AB900X", + "13839": "AB900X", + "13840": "AB890X", + "13841": "AB890X", + "13842": "AB900X", + "13843": "AB900X", + "13844": "AB890X", + "13845": "AB890X", + "13846": "AB900X", + "13847": "AB900X", + "13848": "AB890X", + "13849": "AB900X", + "13850": "AB890X", + "13851": "AB890X", + "13856": "AB900X", + "13859": "AB900X", + "13860": "AB900X", + "13861": "AB900X", + "13862": "AB890X", + "13863": "AB890X", + "13864": "AB890X", + "13865": "AB890X", + "13901": "AB890X", + "13902": "AB890X", + "13903": "AB890X", + "13904": "AB890X", + "13905": "AB890X", + "14001": "AB900X", + "14004": "AB900X", + "14005": "AB900X", + "14006": "AB900X", + "14008": "AB900X", + "14009": "AB900X", + "14010": "AB900X", + "14011": "AB900X", + "14012": "AB900X", + "14013": "AB900X", + "14020": "AB900X", + "14021": "AB900X", + "14024": "AB900X", + "14025": "AB900X", + "14026": "AB900X", + "14027": "AB900X", + "14028": "AB900X", + "14029": "AB900X", + "14030": "AB900X", + "14031": "AB900X", + "14032": "AB900X", + "14033": "AB900X", + "14034": "AB900X", + "14035": "AB900X", + "14036": "AB900X", + "14037": "AB900X", + "14038": "AB900X", + "14039": "AB900X", + "14040": "AB900X", + "14041": "AB900X", + "14042": "AB900X", + "14043": "AB900X", + "14047": "AB900X", + "14048": "AB900X", + "14051": "AB900X", + "14052": "AB900X", + "14054": "AB900X", + "14055": "AB900X", + "14056": "AB900X", + "14057": "AB900X", + "14058": "AB900X", + "14059": "AB900X", + "14060": "AB900X", + "14061": "AB900X", + "14062": "AB900X", + "14063": "AB900X", + "14065": "AB900X", + "14066": "AB900X", + "14067": "AB900X", + "14068": "AB900X", + "14069": "AB900X", + "14070": "AB900X", + "14072": "AB900X", + "14075": "AB900X", + "14080": "AB900X", + "14081": "AB900X", + "14082": "AB900X", + "14083": "AB900X", + "14085": "AB900X", + "14086": "AB900X", + "14091": "AB900X", + "14092": "AB900X", + "14094": "AB900X", + "14095": "AB900X", + "14098": "AB900X", + "14101": "AB900X", + "14102": "AB900X", + "14103": "AB900X", + "14105": "AB900X", + "14107": "AB900X", + "14108": "AB900X", + "14109": "AB900X", + "14110": "AB900X", + "14111": "AB900X", + "14112": "AB900X", + "14113": "AB900X", + "14120": "AB900X", + "14125": "AB900X", + "14126": "AB900X", + "14127": "AB900X", + "14129": "AB900X", + "14130": "AB900X", + "14131": "AB900X", + "14132": "AB900X", + "14133": "AB900X", + "14134": "AB900X", + "14135": "AB900X", + "14136": "AB900X", + "14138": "AB900X", + "14139": "AB900X", + "14140": "AB900X", + "14141": "AB900X", + "14143": "AB900X", + "14144": "AB900X", + "14145": "AB900X", + "14150": "AB900X", + "14151": "AB900X", + "14166": "AB900X", + "14167": "AB900X", + "14168": "AB900X", + "14169": "AB900X", + "14170": "AB900X", + "14171": "AB900X", + "14172": "AB900X", + "14173": "AB900X", + "14174": "AB900X", + "14201": "AB900X", + "14202": "AB900X", + "14203": "AB900X", + "14204": "AB900X", + "14205": "AB900X", + "14206": "AB900X", + "14207": "AB900X", + "14208": "AB900X", + "14209": "AB900X", + "14210": "AB900X", + "14211": "AB900X", + "14212": "AB900X", + "14213": "AB900X", + "14214": "AB900X", + "14215": "AB900X", + "14216": "AB900X", + "14217": "AB900X", + "14218": "AB900X", + "14219": "AB900X", + "14220": "AB900X", + "14221": "AB900X", + "14222": "AB900X", + "14223": "AB900X", + "14224": "AB900X", + "14225": "AB900X", + "14226": "AB900X", + "14227": "AB900X", + "14228": "AB900X", + "14231": "AB900X", + "14233": "AB900X", + "14240": "AB900X", + "14241": "AB900X", + "14260": "AB900X", + "14261": "AB900X", + "14263": "AB900X", + "14264": "AB900X", + "14265": "AB900X", + "14267": "AB900X", + "14269": "AB900X", + "14270": "AB900X", + "14272": "AB900X", + "14273": "AB900X", + "14276": "AB900X", + "14280": "AB900X", + "14301": "AB900X", + "14302": "AB900X", + "14303": "AB900X", + "14304": "AB900X", + "14305": "AB900X", + "14410": "AB900X", + "14411": "AB900X", + "14413": "AB900X", + "14414": "AB900X", + "14415": "AB900X", + "14416": "AB900X", + "14418": "AB900X", + "14420": "AB900X", + "14422": "AB900X", + "14423": "AB900X", + "14424": "AB900X", + "14425": "AB900X", + "14427": "AB900X", + "14428": "AB900X", + "14429": "AB900X", + "14430": "AB900X", + "14432": "AB900X", + "14433": "AB900X", + "14435": "AB900X", + "14437": "AB900X", + "14441": "AB900X", + "14443": "AB900X", + "14445": "AB900X", + "14449": "AB900X", + "14450": "AB900X", + "14452": "AB900X", + "14453": "AB900X", + "14454": "AB900X", + "14456": "AB900X", + "14461": "AB900X", + "14462": "AB900X", + "14463": "AB900X", + "14464": "AB900X", + "14466": "AB900X", + "14467": "AB900X", + "14468": "AB900X", + "14469": "AB900X", + "14470": "AB900X", + "14471": "AB900X", + "14472": "AB900X", + "14475": "AB900X", + "14476": "AB900X", + "14477": "AB900X", + "14478": "AB900X", + "14479": "AB900X", + "14480": "AB900X", + "14481": "AB900X", + "14482": "AB900X", + "14485": "AB900X", + "14486": "AB900X", + "14487": "AB900X", + "14488": "AB900X", + "14489": "AB900X", + "14502": "AB900X", + "14504": "AB900X", + "14505": "AB900X", + "14506": "AB900X", + "14507": "AB900X", + "14508": "AB900X", + "14510": "AB900X", + "14511": "AB900X", + "14512": "AB900X", + "14513": "AB900X", + "14514": "AB900X", + "14515": "AB900X", + "14516": "AB900X", + "14517": "AB900X", + "14518": "AB900X", + "14519": "AB900X", + "14520": "AB900X", + "14521": "AB900X", + "14522": "AB900X", + "14525": "AB900X", + "14526": "AB900X", + "14527": "AB900X", + "14529": "AB890X", + "14530": "AB900X", + "14532": "AB900X", + "14533": "AB900X", + "14534": "AB900X", + "14536": "AB900X", + "14537": "AB900X", + "14538": "AB900X", + "14539": "AB900X", + "14541": "AB900X", + "14542": "AB900X", + "14543": "AB900X", + "14544": "AB900X", + "14545": "AB900X", + "14546": "AB900X", + "14547": "AB900X", + "14548": "AB900X", + "14549": "AB900X", + "14550": "AB900X", + "14551": "AB900X", + "14555": "AB900X", + "14556": "AB900X", + "14557": "AB900X", + "14558": "AB900X", + "14559": "AB900X", + "14560": "AB900X", + "14561": "AB900X", + "14563": "AB900X", + "14564": "AB900X", + "14568": "AB900X", + "14569": "AB900X", + "14571": "AB900X", + "14572": "AB900X", + "14580": "AB900X", + "14585": "AB900X", + "14586": "AB900X", + "14588": "AB900X", + "14589": "AB900X", + "14590": "AB900X", + "14591": "AB900X", + "14592": "AB900X", + "14602": "AB900X", + "14603": "AB900X", + "14604": "AB900X", + "14605": "AB900X", + "14606": "AB900X", + "14607": "AB900X", + "14608": "AB900X", + "14609": "AB900X", + "14610": "AB900X", + "14611": "AB900X", + "14612": "AB900X", + "14613": "AB900X", + "14614": "AB900X", + "14615": "AB900X", + "14616": "AB900X", + "14617": "AB900X", + "14618": "AB900X", + "14619": "AB900X", + "14620": "AB900X", + "14621": "AB900X", + "14622": "AB900X", + "14623": "AB900X", + "14624": "AB900X", + "14625": "AB900X", + "14626": "AB900X", + "14627": "AB900X", + "14638": "AB900X", + "14639": "AB900X", + "14642": "AB900X", + "14643": "AB900X", + "14644": "AB900X", + "14645": "AB900X", + "14646": "AB900X", + "14647": "AB900X", + "14649": "AB900X", + "14650": "AB900X", + "14651": "AB900X", + "14652": "AB900X", + "14653": "AB900X", + "14664": "AB900X", + "14673": "AB900X", + "14683": "AB900X", + "14692": "AB900X", + "14694": "AB900X", + "14701": "AB900X", + "14702": "AB900X", + "14706": "AB900X", + "14707": "AB900X", + "14708": "AB900X", + "14709": "AB900X", + "14710": "AB900X", + "14711": "AB900X", + "14712": "AB900X", + "14714": "AB900X", + "14715": "AB900X", + "14716": "AB900X", + "14717": "AB900X", + "14718": "AB900X", + "14719": "AB900X", + "14720": "AB900X", + "14721": "AB900X", + "14722": "AB900X", + "14723": "AB900X", + "14724": "AB900X", + "14726": "AB900X", + "14727": "AB900X", + "14728": "AB900X", + "14729": "AB900X", + "14730": "AB900X", + "14731": "AB900X", + "14732": "AB900X", + "14733": "AB900X", + "14735": "AB900X", + "14736": "AB900X", + "14737": "AB900X", + "14738": "AB900X", + "14739": "AB900X", + "14740": "AB900X", + "14741": "AB900X", + "14742": "AB900X", + "14743": "AB900X", + "14744": "AB900X", + "14745": "AB900X", + "14747": "AB900X", + "14748": "AB900X", + "14750": "AB900X", + "14751": "AB900X", + "14752": "AB900X", + "14753": "AB900X", + "14754": "AB900X", + "14755": "AB900X", + "14756": "AB900X", + "14757": "AB900X", + "14758": "AB900X", + "14760": "AB900X", + "14762": "AB900X", + "14766": "AB900X", + "14767": "AB900X", + "14769": "AB900X", + "14770": "AB900X", + "14772": "AB900X", + "14774": "AB900X", + "14775": "AB900X", + "14777": "AB900X", + "14778": "AB900X", + "14779": "AB900X", + "14781": "AB900X", + "14782": "AB900X", + "14783": "AB900X", + "14784": "AB900X", + "14785": "AB900X", + "14786": "AB900X", + "14787": "AB900X", + "14788": "AB900X", + "14801": "AB890X", + "14802": "AB900X", + "14803": "AB900X", + "14804": "AB900X", + "14805": "AB890X", + "14806": "AB900X", + "14807": "AB900X", + "14808": "AB900X", + "14809": "AB900X", + "14810": "AB890X", + "14812": "AB890X", + "14813": "AB900X", + "14814": "AB890X", + "14815": "AB890X", + "14816": "AB890X", + "14817": "AB900X", + "14818": "AB890X", + "14819": "AB890X", + "14820": "AB890X", + "14821": "AB890X", + "14822": "AB900X", + "14823": "AB890X", + "14824": "AB890X", + "14825": "AB890X", + "14826": "AB900X", + "14827": "AB890X", + "14830": "AB890X", + "14831": "AB890X", + "14836": "AB900X", + "14837": "AB900X", + "14838": "AB890X", + "14839": "AB890X", + "14840": "AB890X", + "14841": "AB890X", + "14842": "AB900X", + "14843": "AB890X", + "14845": "AB890X", + "14846": "AB900X", + "14847": "AB900X", + "14850": "AB900X", + "14851": "AB900X", + "14852": "AB900X", + "14853": "AB900X", + "14854": "AB900X", + "14855": "AB890X", + "14856": "AB890X", + "14857": "AB900X", + "14858": "AB890X", + "14859": "AB890X", + "14860": "AB900X", + "14861": "AB890X", + "14863": "AB890X", + "14864": "AB890X", + "14865": "AB890X", + "14867": "AB900X", + "14869": "AB890X", + "14870": "AB890X", + "14871": "AB890X", + "14872": "AB890X", + "14873": "AB890X", + "14874": "AB890X", + "14876": "AB890X", + "14877": "AB890X", + "14878": "AB900X", + "14879": "AB890X", + "14880": "AB900X", + "14881": "AB900X", + "14882": "AB900X", + "14883": "AB890X", + "14884": "AB900X", + "14885": "AB890X", + "14886": "AB900X", + "14887": "AB890X", + "14889": "AB890X", + "14891": "AB890X", + "14892": "AB890X", + "14893": "AB890X", + "14894": "AB890X", + "14895": "AB900X", + "14897": "AB900X", + "14898": "AB890X", + "14901": "AB890X", + "14902": "AB890X", + "14903": "AB890X", + "14904": "AB890X", + "14905": "AB890X", + "14925": "AB890X", + "15001": "AB900X", + "15003": "AB900X", + "15004": "AB900X", + "15005": "AB900X", + "15006": "AB900X", + "15007": "AB900X", + "15009": "AB900X", + "15010": "AB900X", + "15012": "AB900X", + "15014": "AB900X", + "15015": "AB900X", + "15017": "AB900X", + "15018": "AB900X", + "15019": "AB900X", + "15020": "AB900X", + "15021": "AB900X", + "15022": "AB900X", + "15024": "AB900X", + "15025": "AB900X", + "15026": "AB900X", + "15027": "AB900X", + "15028": "AB900X", + "15030": "AB900X", + "15031": "AB900X", + "15032": "AB900X", + "15033": "AB900X", + "15034": "AB900X", + "15035": "AB900X", + "15037": "AB900X", + "15038": "AB900X", + "15042": "AB900X", + "15043": "AB900X", + "15044": "AB900X", + "15045": "AB900X", + "15046": "AB900X", + "15047": "AB900X", + "15049": "AB900X", + "15050": "AB900X", + "15051": "AB900X", + "15052": "AB900X", + "15053": "AB900X", + "15054": "AB900X", + "15055": "AB900X", + "15056": "AB900X", + "15057": "AB900X", + "15059": "AB900X", + "15060": "AB900X", + "15061": "AB900X", + "15062": "AB900X", + "15063": "AB900X", + "15064": "AB900X", + "15065": "AB900X", + "15066": "AB900X", + "15067": "AB900X", + "15068": "AB900X", + "15069": "AB900X", + "15071": "AB900X", + "15072": "AB900X", + "15074": "AB900X", + "15075": "AB900X", + "15076": "AB900X", + "15077": "AB900X", + "15078": "AB900X", + "15081": "AB900X", + "15082": "AB900X", + "15083": "AB900X", + "15084": "AB900X", + "15085": "AB900X", + "15086": "AB900X", + "15087": "AB900X", + "15088": "AB900X", + "15089": "AB900X", + "15090": "AB900X", + "15091": "AB900X", + "15095": "AB900X", + "15096": "AB900X", + "15101": "AB900X", + "15102": "AB900X", + "15104": "AB900X", + "15106": "AB900X", + "15108": "AB900X", + "15110": "AB900X", + "15112": "AB900X", + "15116": "AB900X", + "15120": "AB900X", + "15122": "AB900X", + "15123": "AB900X", + "15126": "AB900X", + "15127": "AB900X", + "15129": "AB900X", + "15131": "AB900X", + "15132": "AB900X", + "15133": "AB900X", + "15134": "AB900X", + "15135": "AB900X", + "15136": "AB900X", + "15137": "AB900X", + "15139": "AB900X", + "15140": "AB900X", + "15142": "AB900X", + "15143": "AB900X", + "15144": "AB900X", + "15145": "AB900X", + "15146": "AB900X", + "15147": "AB900X", + "15148": "AB900X", + "15201": "AB900X", + "15202": "AB900X", + "15203": "AB900X", + "15204": "AB900X", + "15205": "AB900X", + "15206": "AB900X", + "15207": "AB900X", + "15208": "AB900X", + "15209": "AB900X", + "15210": "AB900X", + "15211": "AB900X", + "15212": "AB900X", + "15213": "AB900X", + "15214": "AB900X", + "15215": "AB900X", + "15216": "AB900X", + "15217": "AB900X", + "15218": "AB900X", + "15219": "AB900X", + "15220": "AB900X", + "15221": "AB900X", + "15222": "AB900X", + "15223": "AB900X", + "15224": "AB900X", + "15225": "AB900X", + "15226": "AB900X", + "15227": "AB900X", + "15228": "AB900X", + "15229": "AB900X", + "15230": "AB900X", + "15231": "AB900X", + "15232": "AB900X", + "15233": "AB900X", + "15234": "AB900X", + "15235": "AB900X", + "15236": "AB900X", + "15237": "AB900X", + "15238": "AB900X", + "15239": "AB900X", + "15240": "AB900X", + "15241": "AB900X", + "15242": "AB900X", + "15243": "AB900X", + "15244": "AB900X", + "15250": "AB900X", + "15251": "AB900X", + "15252": "AB900X", + "15253": "AB900X", + "15254": "AB900X", + "15255": "AB900X", + "15257": "AB900X", + "15258": "AB900X", + "15259": "AB900X", + "15260": "AB900X", + "15261": "AB900X", + "15262": "AB900X", + "15263": "AB900X", + "15264": "AB900X", + "15265": "AB900X", + "15267": "AB900X", + "15268": "AB900X", + "15270": "AB900X", + "15272": "AB900X", + "15274": "AB900X", + "15275": "AB900X", + "15276": "AB900X", + "15277": "AB900X", + "15278": "AB900X", + "15279": "AB900X", + "15281": "AB900X", + "15282": "AB900X", + "15283": "AB900X", + "15285": "AB900X", + "15286": "AB900X", + "15289": "AB900X", + "15290": "AB900X", + "15295": "AB900X", + "15301": "AB900X", + "15310": "AB900X", + "15311": "AB900X", + "15312": "AB900X", + "15313": "AB900X", + "15314": "AB900X", + "15315": "AB900X", + "15316": "AB900X", + "15317": "AB900X", + "15320": "AB900X", + "15321": "AB900X", + "15322": "AB900X", + "15323": "AB900X", + "15324": "AB900X", + "15325": "AB900X", + "15327": "AB900X", + "15329": "AB900X", + "15330": "AB900X", + "15331": "AB900X", + "15332": "AB900X", + "15333": "AB900X", + "15334": "AB900X", + "15336": "AB900X", + "15337": "AB900X", + "15338": "AB900X", + "15339": "AB900X", + "15340": "AB900X", + "15341": "AB900X", + "15342": "AB900X", + "15344": "AB900X", + "15345": "AB900X", + "15346": "AB900X", + "15347": "AB900X", + "15348": "AB900X", + "15349": "AB900X", + "15350": "AB900X", + "15351": "AB900X", + "15352": "AB900X", + "15353": "AB900X", + "15357": "AB900X", + "15358": "AB900X", + "15359": "AB900X", + "15360": "AB900X", + "15361": "AB900X", + "15362": "AB900X", + "15363": "AB900X", + "15364": "AB900X", + "15365": "AB900X", + "15366": "AB900X", + "15367": "AB900X", + "15368": "AB900X", + "15370": "AB900X", + "15376": "AB900X", + "15377": "AB900X", + "15378": "AB900X", + "15379": "AB900X", + "15380": "AB900X", + "15401": "AB900X", + "15410": "AB900X", + "15411": "AB900X", + "15412": "AB900X", + "15413": "AB900X", + "15415": "AB900X", + "15416": "AB900X", + "15417": "AB900X", + "15419": "AB900X", + "15420": "AB900X", + "15421": "AB900X", + "15422": "AB900X", + "15423": "AB900X", + "15424": "AB900X", + "15425": "AB900X", + "15427": "AB900X", + "15428": "AB900X", + "15429": "AB900X", + "15430": "AB900X", + "15431": "AB900X", + "15432": "AB900X", + "15433": "AB900X", + "15434": "AB900X", + "15435": "AB900X", + "15436": "AB900X", + "15437": "AB900X", + "15438": "AB900X", + "15439": "AB900X", + "15440": "AB900X", + "15442": "AB900X", + "15443": "AB900X", + "15444": "AB900X", + "15445": "AB900X", + "15446": "AB900X", + "15447": "AB900X", + "15448": "AB900X", + "15449": "AB900X", + "15450": "AB900X", + "15451": "AB900X", + "15454": "AB900X", + "15455": "AB900X", + "15456": "AB900X", + "15458": "AB900X", + "15459": "AB900X", + "15460": "AB900X", + "15461": "AB900X", + "15462": "AB900X", + "15463": "AB900X", + "15464": "AB900X", + "15465": "AB900X", + "15466": "AB900X", + "15467": "AB900X", + "15468": "AB900X", + "15469": "AB900X", + "15470": "AB900X", + "15472": "AB900X", + "15473": "AB900X", + "15474": "AB900X", + "15475": "AB900X", + "15476": "AB900X", + "15477": "AB900X", + "15478": "AB900X", + "15479": "AB900X", + "15480": "AB900X", + "15482": "AB900X", + "15483": "AB900X", + "15484": "AB900X", + "15485": "AB900X", + "15486": "AB900X", + "15488": "AB900X", + "15489": "AB900X", + "15490": "AB900X", + "15492": "AB900X", + "15501": "AB900X", + "15502": "AB900X", + "15510": "AB900X", + "15520": "AB900X", + "15521": "AB900X", + "15522": "AB900X", + "15530": "AB900X", + "15531": "AB900X", + "15532": "AB900X", + "15533": "AB900X", + "15534": "AB900X", + "15535": "AB900X", + "15536": "AB892X", + "15537": "AB900X", + "15538": "AB900X", + "15539": "AB900X", + "15540": "AB900X", + "15541": "AB900X", + "15542": "AB900X", + "15544": "AB900X", + "15545": "AB900X", + "15546": "AB900X", + "15547": "AB900X", + "15548": "AB900X", + "15549": "AB900X", + "15550": "AB900X", + "15551": "AB900X", + "15552": "AB900X", + "15553": "AB900X", + "15554": "AB900X", + "15555": "AB900X", + "15557": "AB900X", + "15558": "AB900X", + "15559": "AB900X", + "15560": "AB900X", + "15561": "AB900X", + "15562": "AB900X", + "15563": "AB900X", + "15564": "AB900X", + "15565": "AB900X", + "15601": "AB900X", + "15605": "AB900X", + "15606": "AB900X", + "15610": "AB900X", + "15611": "AB900X", + "15612": "AB900X", + "15613": "AB900X", + "15615": "AB900X", + "15616": "AB900X", + "15617": "AB900X", + "15618": "AB900X", + "15619": "AB900X", + "15620": "AB900X", + "15621": "AB900X", + "15622": "AB900X", + "15623": "AB900X", + "15624": "AB900X", + "15625": "AB900X", + "15626": "AB900X", + "15627": "AB900X", + "15628": "AB900X", + "15629": "AB900X", + "15631": "AB900X", + "15632": "AB900X", + "15633": "AB900X", + "15634": "AB900X", + "15635": "AB900X", + "15636": "AB900X", + "15637": "AB900X", + "15638": "AB900X", + "15639": "AB900X", + "15640": "AB900X", + "15641": "AB900X", + "15642": "AB900X", + "15644": "AB900X", + "15646": "AB900X", + "15647": "AB900X", + "15650": "AB900X", + "15655": "AB900X", + "15656": "AB900X", + "15658": "AB900X", + "15660": "AB900X", + "15661": "AB900X", + "15662": "AB900X", + "15663": "AB900X", + "15664": "AB900X", + "15665": "AB900X", + "15666": "AB900X", + "15668": "AB900X", + "15670": "AB900X", + "15671": "AB900X", + "15672": "AB900X", + "15673": "AB900X", + "15674": "AB900X", + "15675": "AB900X", + "15676": "AB900X", + "15677": "AB900X", + "15678": "AB900X", + "15679": "AB900X", + "15680": "AB900X", + "15681": "AB900X", + "15682": "AB900X", + "15683": "AB900X", + "15684": "AB900X", + "15685": "AB900X", + "15686": "AB900X", + "15687": "AB900X", + "15688": "AB900X", + "15689": "AB900X", + "15690": "AB900X", + "15691": "AB900X", + "15692": "AB900X", + "15693": "AB900X", + "15695": "AB900X", + "15696": "AB900X", + "15697": "AB900X", + "15698": "AB900X", + "15701": "AB900X", + "15705": "AB900X", + "15710": "AB900X", + "15711": "AB900X", + "15712": "AB900X", + "15713": "AB900X", + "15714": "AB900X", + "15715": "AB900X", + "15716": "AB900X", + "15717": "AB900X", + "15720": "AB900X", + "15721": "AB900X", + "15722": "AB900X", + "15723": "AB900X", + "15724": "AB900X", + "15725": "AB900X", + "15727": "AB900X", + "15728": "AB900X", + "15729": "AB900X", + "15730": "AB900X", + "15731": "AB900X", + "15732": "AB900X", + "15733": "AB900X", + "15734": "AB900X", + "15736": "AB900X", + "15737": "AB900X", + "15738": "AB900X", + "15739": "AB900X", + "15740": "AB900X", + "15741": "AB900X", + "15742": "AB900X", + "15744": "AB900X", + "15745": "AB900X", + "15746": "AB900X", + "15747": "AB900X", + "15748": "AB900X", + "15750": "AB900X", + "15752": "AB900X", + "15753": "AB900X", + "15754": "AB900X", + "15756": "AB900X", + "15757": "AB900X", + "15758": "AB900X", + "15759": "AB900X", + "15760": "AB900X", + "15761": "AB900X", + "15762": "AB900X", + "15763": "AB900X", + "15764": "AB900X", + "15765": "AB900X", + "15767": "AB900X", + "15770": "AB900X", + "15771": "AB900X", + "15772": "AB900X", + "15773": "AB900X", + "15774": "AB900X", + "15775": "AB900X", + "15776": "AB900X", + "15777": "AB900X", + "15778": "AB900X", + "15779": "AB900X", + "15780": "AB900X", + "15781": "AB900X", + "15783": "AB900X", + "15784": "AB900X", + "15801": "AB900X", + "15821": "AB900X", + "15822": "AB900X", + "15823": "AB900X", + "15824": "AB900X", + "15825": "AB900X", + "15827": "AB900X", + "15828": "AB900X", + "15829": "AB900X", + "15831": "AB900X", + "15832": "AB900X", + "15834": "AB900X", + "15840": "AB900X", + "15841": "AB900X", + "15845": "AB900X", + "15846": "AB900X", + "15847": "AB900X", + "15848": "AB900X", + "15849": "AB900X", + "15851": "AB900X", + "15853": "AB900X", + "15856": "AB900X", + "15857": "AB900X", + "15860": "AB900X", + "15861": "AB900X", + "15863": "AB900X", + "15864": "AB900X", + "15865": "AB900X", + "15866": "AB900X", + "15868": "AB900X", + "15870": "AB900X", + "15901": "AB900X", + "15902": "AB900X", + "15904": "AB900X", + "15905": "AB900X", + "15906": "AB900X", + "15907": "AB900X", + "15909": "AB900X", + "15915": "AB900X", + "15920": "AB900X", + "15921": "AB900X", + "15922": "AB900X", + "15923": "AB900X", + "15924": "AB900X", + "15925": "AB900X", + "15926": "AB900X", + "15927": "AB900X", + "15928": "AB900X", + "15929": "AB900X", + "15930": "AB900X", + "15931": "AB900X", + "15934": "AB900X", + "15935": "AB900X", + "15936": "AB900X", + "15937": "AB900X", + "15938": "AB900X", + "15940": "AB900X", + "15942": "AB900X", + "15943": "AB900X", + "15944": "AB900X", + "15945": "AB900X", + "15946": "AB900X", + "15948": "AB900X", + "15949": "AB900X", + "15951": "AB900X", + "15952": "AB900X", + "15953": "AB900X", + "15954": "AB900X", + "15955": "AB900X", + "15956": "AB900X", + "15957": "AB900X", + "15958": "AB900X", + "15959": "AB900X", + "15960": "AB900X", + "15961": "AB900X", + "15962": "AB900X", + "15963": "AB900X", + "15989": "AB900X", + "16001": "AB900X", + "16002": "AB900X", + "16003": "AB900X", + "16016": "AB900X", + "16017": "AB900X", + "16018": "AB900X", + "16020": "AB900X", + "16021": "AB900X", + "16022": "AB900X", + "16023": "AB900X", + "16024": "AB900X", + "16025": "AB900X", + "16027": "AB900X", + "16028": "AB900X", + "16029": "AB900X", + "16030": "AB900X", + "16033": "AB900X", + "16034": "AB900X", + "16035": "AB900X", + "16036": "AB900X", + "16037": "AB900X", + "16038": "AB900X", + "16039": "AB900X", + "16040": "AB900X", + "16041": "AB900X", + "16045": "AB900X", + "16046": "AB900X", + "16048": "AB900X", + "16049": "AB900X", + "16050": "AB900X", + "16051": "AB900X", + "16052": "AB900X", + "16053": "AB900X", + "16054": "AB900X", + "16055": "AB900X", + "16056": "AB900X", + "16057": "AB900X", + "16058": "AB900X", + "16059": "AB900X", + "16061": "AB900X", + "16063": "AB900X", + "16066": "AB900X", + "16101": "AB900X", + "16102": "AB900X", + "16103": "AB900X", + "16105": "AB900X", + "16107": "AB900X", + "16108": "AB900X", + "16110": "AB900X", + "16111": "AB900X", + "16112": "AB900X", + "16113": "AB900X", + "16114": "AB900X", + "16115": "AB900X", + "16116": "AB900X", + "16117": "AB900X", + "16120": "AB900X", + "16121": "AB900X", + "16123": "AB900X", + "16124": "AB900X", + "16125": "AB900X", + "16127": "AB900X", + "16130": "AB900X", + "16131": "AB900X", + "16132": "AB900X", + "16133": "AB900X", + "16134": "AB900X", + "16136": "AB900X", + "16137": "AB900X", + "16140": "AB900X", + "16141": "AB900X", + "16142": "AB900X", + "16143": "AB900X", + "16145": "AB900X", + "16146": "AB900X", + "16148": "AB900X", + "16150": "AB900X", + "16151": "AB900X", + "16153": "AB900X", + "16154": "AB900X", + "16155": "AB900X", + "16156": "AB900X", + "16157": "AB900X", + "16159": "AB900X", + "16160": "AB900X", + "16161": "AB900X", + "16172": "AB900X", + "16201": "AB900X", + "16210": "AB900X", + "16211": "AB900X", + "16212": "AB900X", + "16213": "AB900X", + "16214": "AB900X", + "16215": "AB900X", + "16217": "AB900X", + "16218": "AB900X", + "16220": "AB900X", + "16221": "AB900X", + "16222": "AB900X", + "16223": "AB900X", + "16224": "AB900X", + "16225": "AB900X", + "16226": "AB900X", + "16228": "AB900X", + "16229": "AB900X", + "16230": "AB900X", + "16232": "AB900X", + "16233": "AB900X", + "16234": "AB900X", + "16235": "AB900X", + "16236": "AB900X", + "16238": "AB900X", + "16239": "AB900X", + "16240": "AB900X", + "16242": "AB900X", + "16244": "AB900X", + "16245": "AB900X", + "16246": "AB900X", + "16248": "AB900X", + "16249": "AB900X", + "16250": "AB900X", + "16253": "AB900X", + "16254": "AB900X", + "16255": "AB900X", + "16256": "AB900X", + "16257": "AB900X", + "16258": "AB900X", + "16259": "AB900X", + "16260": "AB900X", + "16261": "AB900X", + "16262": "AB900X", + "16263": "AB900X", + "16301": "AB900X", + "16311": "AB900X", + "16312": "AB900X", + "16313": "AB900X", + "16314": "AB900X", + "16316": "AB900X", + "16317": "AB900X", + "16319": "AB900X", + "16321": "AB900X", + "16322": "AB900X", + "16323": "AB900X", + "16326": "AB900X", + "16327": "AB900X", + "16328": "AB900X", + "16329": "AB900X", + "16331": "AB900X", + "16332": "AB900X", + "16333": "AB900X", + "16334": "AB900X", + "16335": "AB900X", + "16340": "AB900X", + "16341": "AB900X", + "16342": "AB900X", + "16343": "AB900X", + "16344": "AB900X", + "16345": "AB900X", + "16346": "AB900X", + "16347": "AB900X", + "16350": "AB900X", + "16351": "AB900X", + "16352": "AB900X", + "16353": "AB900X", + "16354": "AB900X", + "16360": "AB900X", + "16361": "AB900X", + "16362": "AB900X", + "16364": "AB900X", + "16365": "AB900X", + "16366": "AB900X", + "16367": "AB900X", + "16368": "AB900X", + "16369": "AB900X", + "16370": "AB900X", + "16371": "AB900X", + "16372": "AB900X", + "16373": "AB900X", + "16374": "AB900X", + "16375": "AB900X", + "16388": "AB900X", + "16401": "AB900X", + "16402": "AB900X", + "16403": "AB900X", + "16404": "AB900X", + "16405": "AB900X", + "16406": "AB900X", + "16407": "AB900X", + "16410": "AB900X", + "16411": "AB900X", + "16412": "AB900X", + "16413": "AB900X", + "16415": "AB900X", + "16416": "AB900X", + "16417": "AB900X", + "16420": "AB900X", + "16421": "AB900X", + "16422": "AB900X", + "16423": "AB900X", + "16424": "AB900X", + "16426": "AB900X", + "16427": "AB900X", + "16428": "AB900X", + "16430": "AB900X", + "16432": "AB900X", + "16433": "AB900X", + "16434": "AB900X", + "16435": "AB900X", + "16436": "AB900X", + "16438": "AB900X", + "16440": "AB900X", + "16441": "AB900X", + "16442": "AB900X", + "16443": "AB900X", + "16444": "AB900X", + "16475": "AB900X", + "16501": "AB900X", + "16502": "AB900X", + "16503": "AB900X", + "16504": "AB900X", + "16505": "AB900X", + "16506": "AB900X", + "16507": "AB900X", + "16508": "AB900X", + "16509": "AB900X", + "16510": "AB900X", + "16511": "AB900X", + "16512": "AB900X", + "16514": "AB900X", + "16515": "AB900X", + "16522": "AB900X", + "16530": "AB900X", + "16531": "AB900X", + "16532": "AB900X", + "16533": "AB900X", + "16534": "AB900X", + "16538": "AB900X", + "16541": "AB900X", + "16544": "AB900X", + "16546": "AB900X", + "16550": "AB900X", + "16553": "AB900X", + "16554": "AB900X", + "16563": "AB900X", + "16565": "AB900X", + "16601": "AB900X", + "16602": "AB900X", + "16603": "AB900X", + "16611": "AB900X", + "16613": "AB900X", + "16616": "AB900X", + "16617": "AB900X", + "16619": "AB900X", + "16620": "AB900X", + "16621": "AB900X", + "16622": "AB900X", + "16623": "AB900X", + "16624": "AB900X", + "16625": "AB900X", + "16627": "AB900X", + "16629": "AB900X", + "16630": "AB900X", + "16631": "AB900X", + "16633": "AB900X", + "16634": "AB900X", + "16635": "AB900X", + "16636": "AB900X", + "16637": "AB900X", + "16638": "AB900X", + "16639": "AB900X", + "16640": "AB900X", + "16641": "AB900X", + "16644": "AB900X", + "16645": "AB900X", + "16646": "AB900X", + "16647": "AB900X", + "16648": "AB900X", + "16650": "AB900X", + "16651": "AB900X", + "16652": "AB900X", + "16654": "AB900X", + "16655": "AB900X", + "16656": "AB900X", + "16657": "AB900X", + "16659": "AB900X", + "16660": "AB900X", + "16661": "AB900X", + "16662": "AB900X", + "16663": "AB900X", + "16664": "AB900X", + "16665": "AB900X", + "16666": "AB900X", + "16667": "AB900X", + "16668": "AB900X", + "16669": "AB900X", + "16670": "AB900X", + "16671": "AB900X", + "16672": "AB900X", + "16673": "AB900X", + "16674": "AB900X", + "16675": "AB900X", + "16677": "AB900X", + "16678": "AB900X", + "16679": "AB900X", + "16680": "AB900X", + "16681": "AB900X", + "16682": "AB900X", + "16683": "AB900X", + "16684": "AB900X", + "16685": "AB900X", + "16686": "AB900X", + "16689": "AB892X", + "16691": "AB892X", + "16692": "AB900X", + "16693": "AB900X", + "16694": "AB900X", + "16695": "AB900X", + "16698": "AB900X", + "16699": "AB900X", + "16701": "AB900X", + "16720": "AB900X", + "16724": "AB900X", + "16725": "AB900X", + "16726": "AB900X", + "16727": "AB900X", + "16728": "AB900X", + "16729": "AB900X", + "16730": "AB900X", + "16731": "AB900X", + "16732": "AB900X", + "16733": "AB900X", + "16734": "AB900X", + "16735": "AB900X", + "16738": "AB900X", + "16740": "AB900X", + "16743": "AB900X", + "16744": "AB900X", + "16745": "AB900X", + "16746": "AB900X", + "16748": "AB900X", + "16749": "AB900X", + "16750": "AB900X", + "16801": "AB900X", + "16802": "AB900X", + "16803": "AB900X", + "16804": "AB900X", + "16805": "AB900X", + "16820": "AB900X", + "16821": "AB900X", + "16822": "AB890X", + "16823": "AB900X", + "16825": "AB900X", + "16826": "AB890X", + "16827": "AB900X", + "16828": "AB890X", + "16829": "AB900X", + "16830": "AB900X", + "16832": "AB900X", + "16833": "AB900X", + "16834": "AB900X", + "16835": "AB900X", + "16836": "AB900X", + "16837": "AB900X", + "16838": "AB900X", + "16839": "AB900X", + "16840": "AB900X", + "16841": "AB890X", + "16843": "AB900X", + "16844": "AB890X", + "16845": "AB900X", + "16847": "AB900X", + "16848": "AB890X", + "16849": "AB900X", + "16850": "AB900X", + "16851": "AB900X", + "16852": "AB900X", + "16853": "AB890X", + "16854": "AB900X", + "16855": "AB900X", + "16856": "AB900X", + "16858": "AB900X", + "16859": "AB900X", + "16860": "AB900X", + "16861": "AB900X", + "16863": "AB900X", + "16864": "AB900X", + "16865": "AB900X", + "16866": "AB900X", + "16868": "AB900X", + "16870": "AB900X", + "16871": "AB900X", + "16872": "AB890X", + "16873": "AB900X", + "16874": "AB900X", + "16875": "AB900X", + "16876": "AB900X", + "16877": "AB900X", + "16878": "AB900X", + "16879": "AB900X", + "16881": "AB900X", + "16882": "AB900X", + "16901": "AB890X", + "16910": "AB890X", + "16911": "AB890X", + "16912": "AB890X", + "16914": "AB890X", + "16915": "AB900X", + "16917": "AB890X", + "16918": "AB890X", + "16920": "AB890X", + "16921": "AB890X", + "16922": "AB900X", + "16923": "AB900X", + "16925": "AB890X", + "16926": "AB890X", + "16927": "AB890X", + "16928": "AB890X", + "16929": "AB890X", + "16930": "AB890X", + "16932": "AB890X", + "16933": "AB890X", + "16935": "AB890X", + "16936": "AB890X", + "16937": "AB900X", + "16938": "AB890X", + "16939": "AB890X", + "16940": "AB890X", + "16941": "AB900X", + "16942": "AB890X", + "16943": "AB890X", + "16945": "AB890X", + "16946": "AB890X", + "16947": "AB890X", + "16948": "AB890X", + "16950": "AB890X", + "17001": "AB892X", + "17002": "AB892X", + "17003": "AB892X", + "17004": "AB892X", + "17005": "AB892X", + "17006": "AB892X", + "17007": "AB892X", + "17008": "AB892X", + "17009": "AB892X", + "17010": "AB892X", + "17011": "AB892X", + "17012": "AB892X", + "17013": "AB892X", + "17014": "AB892X", + "17015": "AB892X", + "17016": "AB892X", + "17017": "AB892X", + "17018": "AB892X", + "17019": "AB892X", + "17020": "AB892X", + "17021": "AB892X", + "17022": "AB892X", + "17023": "AB892X", + "17024": "AB892X", + "17025": "AB892X", + "17026": "AB892X", + "17027": "AB892X", + "17028": "AB892X", + "17029": "AB892X", + "17030": "AB892X", + "17032": "AB892X", + "17033": "AB892X", + "17034": "AB892X", + "17035": "AB892X", + "17036": "AB892X", + "17037": "AB892X", + "17038": "AB892X", + "17039": "AB892X", + "17040": "AB892X", + "17041": "AB892X", + "17042": "AB892X", + "17043": "AB892X", + "17044": "AB892X", + "17045": "AB890X", + "17046": "AB892X", + "17047": "AB892X", + "17048": "AB892X", + "17049": "AB892X", + "17050": "AB892X", + "17051": "AB892X", + "17052": "AB900X", + "17053": "AB892X", + "17054": "AB892X", + "17055": "AB892X", + "17056": "AB892X", + "17057": "AB892X", + "17058": "AB892X", + "17059": "AB892X", + "17060": "AB900X", + "17061": "AB892X", + "17062": "AB892X", + "17063": "AB892X", + "17064": "AB892X", + "17065": "AB892X", + "17066": "AB892X", + "17067": "AB892X", + "17068": "AB892X", + "17069": "AB892X", + "17070": "AB892X", + "17071": "AB892X", + "17072": "AB892X", + "17073": "AB892X", + "17074": "AB892X", + "17075": "AB892X", + "17076": "AB892X", + "17077": "AB892X", + "17078": "AB892X", + "17080": "AB892X", + "17081": "AB892X", + "17082": "AB892X", + "17083": "AB892X", + "17084": "AB892X", + "17085": "AB892X", + "17086": "AB892X", + "17087": "AB892X", + "17088": "AB892X", + "17089": "AB892X", + "17090": "AB892X", + "17091": "AB892X", + "17093": "AB892X", + "17094": "AB892X", + "17097": "AB892X", + "17098": "AB892X", + "17099": "AB892X", + "17101": "AB892X", + "17102": "AB892X", + "17103": "AB892X", + "17104": "AB892X", + "17105": "AB892X", + "17106": "AB892X", + "17107": "AB892X", + "17108": "AB892X", + "17109": "AB892X", + "17110": "AB892X", + "17111": "AB892X", + "17112": "AB892X", + "17113": "AB892X", + "17120": "AB892X", + "17121": "AB892X", + "17122": "AB892X", + "17123": "AB892X", + "17124": "AB892X", + "17125": "AB892X", + "17126": "AB892X", + "17127": "AB892X", + "17128": "AB892X", + "17129": "AB892X", + "17130": "AB892X", + "17140": "AB892X", + "17177": "AB892X", + "17201": "AB892X", + "17202": "AB892X", + "17210": "AB892X", + "17211": "AB900X", + "17212": "AB892X", + "17213": "AB900X", + "17214": "AB892X", + "17215": "AB892X", + "17217": "AB892X", + "17219": "AB892X", + "17220": "AB892X", + "17221": "AB892X", + "17222": "AB892X", + "17223": "AB892X", + "17224": "AB892X", + "17225": "AB892X", + "17228": "AB892X", + "17229": "AB892X", + "17231": "AB892X", + "17232": "AB892X", + "17233": "AB892X", + "17235": "AB892X", + "17236": "AB892X", + "17237": "AB892X", + "17238": "AB892X", + "17239": "AB900X", + "17240": "AB892X", + "17241": "AB892X", + "17243": "AB900X", + "17244": "AB892X", + "17246": "AB892X", + "17247": "AB892X", + "17249": "AB900X", + "17250": "AB892X", + "17251": "AB892X", + "17252": "AB892X", + "17253": "AB900X", + "17254": "AB892X", + "17255": "AB900X", + "17256": "AB892X", + "17257": "AB892X", + "17260": "AB900X", + "17261": "AB892X", + "17262": "AB892X", + "17263": "AB892X", + "17264": "AB900X", + "17265": "AB892X", + "17266": "AB892X", + "17267": "AB892X", + "17268": "AB892X", + "17270": "AB892X", + "17271": "AB892X", + "17272": "AB892X", + "17301": "AB892X", + "17302": "AB892X", + "17303": "AB892X", + "17304": "AB892X", + "17306": "AB892X", + "17307": "AB892X", + "17309": "AB892X", + "17310": "AB892X", + "17311": "AB892X", + "17312": "AB892X", + "17313": "AB892X", + "17314": "AB892X", + "17315": "AB892X", + "17316": "AB892X", + "17317": "AB892X", + "17318": "AB892X", + "17319": "AB892X", + "17320": "AB892X", + "17321": "AB892X", + "17322": "AB892X", + "17323": "AB892X", + "17324": "AB892X", + "17325": "AB892X", + "17326": "AB892X", + "17327": "AB892X", + "17329": "AB892X", + "17331": "AB892X", + "17332": "AB892X", + "17333": "AB892X", + "17334": "AB892X", + "17337": "AB892X", + "17339": "AB892X", + "17340": "AB892X", + "17342": "AB892X", + "17343": "AB892X", + "17344": "AB892X", + "17345": "AB892X", + "17347": "AB892X", + "17349": "AB892X", + "17350": "AB892X", + "17352": "AB892X", + "17353": "AB892X", + "17354": "AB892X", + "17355": "AB892X", + "17356": "AB892X", + "17358": "AB892X", + "17360": "AB892X", + "17361": "AB892X", + "17362": "AB892X", + "17363": "AB892X", + "17364": "AB892X", + "17365": "AB892X", + "17366": "AB892X", + "17368": "AB892X", + "17370": "AB892X", + "17371": "AB892X", + "17372": "AB892X", + "17375": "AB892X", + "17401": "AB892X", + "17402": "AB892X", + "17403": "AB892X", + "17404": "AB892X", + "17405": "AB892X", + "17406": "AB892X", + "17407": "AB892X", + "17408": "AB892X", + "17415": "AB892X", + "17501": "AB892X", + "17502": "AB892X", + "17503": "AB892X", + "17504": "AB892X", + "17505": "AB892X", + "17506": "AB892X", + "17507": "AB892X", + "17508": "AB892X", + "17509": "AB892X", + "17512": "AB892X", + "17516": "AB892X", + "17517": "AB892X", + "17518": "AB892X", + "17519": "AB892X", + "17520": "AB892X", + "17521": "AB892X", + "17522": "AB892X", + "17527": "AB892X", + "17528": "AB892X", + "17529": "AB892X", + "17532": "AB892X", + "17533": "AB892X", + "17534": "AB892X", + "17535": "AB892X", + "17536": "AB892X", + "17537": "AB892X", + "17538": "AB892X", + "17540": "AB892X", + "17543": "AB892X", + "17545": "AB892X", + "17547": "AB892X", + "17549": "AB892X", + "17550": "AB892X", + "17551": "AB892X", + "17552": "AB892X", + "17554": "AB892X", + "17555": "AB892X", + "17557": "AB892X", + "17560": "AB892X", + "17562": "AB892X", + "17563": "AB892X", + "17564": "AB892X", + "17565": "AB892X", + "17566": "AB892X", + "17567": "AB892X", + "17568": "AB892X", + "17569": "AB892X", + "17570": "AB892X", + "17572": "AB892X", + "17573": "AB892X", + "17575": "AB892X", + "17576": "AB892X", + "17578": "AB892X", + "17579": "AB892X", + "17580": "AB892X", + "17581": "AB892X", + "17582": "AB892X", + "17583": "AB892X", + "17584": "AB892X", + "17585": "AB892X", + "17601": "AB892X", + "17602": "AB892X", + "17603": "AB892X", + "17604": "AB892X", + "17605": "AB892X", + "17606": "AB892X", + "17607": "AB892X", + "17608": "AB892X", + "17611": "AB892X", + "17699": "AB892X", + "17701": "AB890X", + "17702": "AB890X", + "17703": "AB890X", + "17705": "AB890X", + "17720": "AB890X", + "17721": "AB890X", + "17723": "AB890X", + "17724": "AB890X", + "17726": "AB890X", + "17727": "AB890X", + "17728": "AB890X", + "17729": "AB900X", + "17730": "AB890X", + "17731": "AB890X", + "17735": "AB890X", + "17737": "AB890X", + "17738": "AB890X", + "17739": "AB890X", + "17740": "AB890X", + "17742": "AB890X", + "17744": "AB890X", + "17745": "AB890X", + "17747": "AB890X", + "17748": "AB890X", + "17749": "AB890X", + "17750": "AB890X", + "17751": "AB890X", + "17752": "AB890X", + "17754": "AB890X", + "17756": "AB890X", + "17758": "AB890X", + "17760": "AB890X", + "17762": "AB890X", + "17763": "AB890X", + "17764": "AB890X", + "17765": "AB890X", + "17767": "AB890X", + "17768": "AB890X", + "17769": "AB890X", + "17771": "AB890X", + "17772": "AB890X", + "17773": "AB890X", + "17774": "AB890X", + "17776": "AB890X", + "17777": "AB890X", + "17778": "AB890X", + "17779": "AB890X", + "17801": "AB890X", + "17810": "AB890X", + "17812": "AB892X", + "17813": "AB890X", + "17814": "AB890X", + "17815": "AB890X", + "17820": "AB890X", + "17821": "AB890X", + "17822": "AB890X", + "17823": "AB892X", + "17824": "AB890X", + "17827": "AB890X", + "17829": "AB890X", + "17830": "AB892X", + "17831": "AB890X", + "17832": "AB890X", + "17833": "AB890X", + "17834": "AB890X", + "17835": "AB890X", + "17836": "AB890X", + "17837": "AB890X", + "17839": "AB890X", + "17840": "AB890X", + "17841": "AB892X", + "17842": "AB890X", + "17843": "AB890X", + "17844": "AB890X", + "17845": "AB890X", + "17846": "AB890X", + "17847": "AB890X", + "17850": "AB890X", + "17851": "AB890X", + "17853": "AB890X", + "17855": "AB890X", + "17856": "AB890X", + "17857": "AB890X", + "17858": "AB890X", + "17859": "AB890X", + "17860": "AB890X", + "17861": "AB890X", + "17862": "AB890X", + "17864": "AB890X", + "17865": "AB890X", + "17866": "AB890X", + "17867": "AB890X", + "17868": "AB890X", + "17870": "AB890X", + "17872": "AB890X", + "17876": "AB890X", + "17877": "AB890X", + "17878": "AB890X", + "17880": "AB890X", + "17881": "AB890X", + "17882": "AB890X", + "17883": "AB890X", + "17884": "AB890X", + "17885": "AB890X", + "17886": "AB890X", + "17887": "AB890X", + "17888": "AB890X", + "17889": "AB890X", + "17901": "AB890X", + "17920": "AB890X", + "17921": "AB890X", + "17922": "AB890X", + "17923": "AB890X", + "17925": "AB890X", + "17929": "AB890X", + "17930": "AB890X", + "17931": "AB890X", + "17932": "AB890X", + "17933": "AB890X", + "17934": "AB890X", + "17935": "AB890X", + "17936": "AB890X", + "17938": "AB892X", + "17941": "AB892X", + "17942": "AB890X", + "17943": "AB890X", + "17944": "AB890X", + "17945": "AB890X", + "17946": "AB890X", + "17948": "AB890X", + "17949": "AB890X", + "17951": "AB890X", + "17952": "AB890X", + "17953": "AB890X", + "17954": "AB890X", + "17957": "AB892X", + "17959": "AB890X", + "17960": "AB890X", + "17961": "AB890X", + "17963": "AB890X", + "17964": "AB890X", + "17965": "AB890X", + "17966": "AB890X", + "17967": "AB890X", + "17968": "AB892X", + "17970": "AB890X", + "17972": "AB890X", + "17974": "AB890X", + "17976": "AB890X", + "17978": "AB892X", + "17979": "AB890X", + "17980": "AB892X", + "17981": "AB890X", + "17982": "AB890X", + "17983": "AB892X", + "17985": "AB890X", + "18001": "AB890X", + "18002": "AB890X", + "18003": "AB890X", + "18010": "AB890X", + "18011": "AB890X", + "18012": "AB890X", + "18013": "AB890X", + "18014": "AB890X", + "18015": "AB890X", + "18016": "AB890X", + "18017": "AB890X", + "18018": "AB890X", + "18020": "AB890X", + "18025": "AB890X", + "18030": "AB890X", + "18031": "AB890X", + "18032": "AB890X", + "18034": "AB890X", + "18035": "AB890X", + "18036": "AB890X", + "18037": "AB890X", + "18038": "AB890X", + "18039": "AB890X", + "18040": "AB890X", + "18041": "AB890X", + "18042": "AB890X", + "18043": "AB890X", + "18044": "AB890X", + "18045": "AB890X", + "18046": "AB890X", + "18049": "AB890X", + "18050": "AB890X", + "18051": "AB890X", + "18052": "AB890X", + "18053": "AB890X", + "18054": "AB890X", + "18055": "AB890X", + "18056": "AB890X", + "18058": "AB890X", + "18059": "AB890X", + "18060": "AB890X", + "18062": "AB890X", + "18063": "AB890X", + "18064": "AB890X", + "18065": "AB890X", + "18066": "AB890X", + "18067": "AB890X", + "18068": "AB890X", + "18069": "AB890X", + "18070": "AB890X", + "18071": "AB890X", + "18072": "AB890X", + "18073": "AB890X", + "18074": "AB890X", + "18076": "AB890X", + "18077": "AB890X", + "18078": "AB890X", + "18079": "AB890X", + "18080": "AB890X", + "18081": "AB890X", + "18083": "AB890X", + "18084": "AB890X", + "18085": "AB890X", + "18086": "AB890X", + "18087": "AB890X", + "18088": "AB890X", + "18091": "AB890X", + "18092": "AB890X", + "18098": "AB890X", + "18099": "AB890X", + "18101": "AB890X", + "18102": "AB890X", + "18103": "AB890X", + "18104": "AB890X", + "18105": "AB890X", + "18106": "AB890X", + "18109": "AB890X", + "18175": "AB890X", + "18195": "AB890X", + "18201": "AB890X", + "18202": "AB890X", + "18210": "AB890X", + "18211": "AB890X", + "18212": "AB890X", + "18214": "AB890X", + "18216": "AB890X", + "18218": "AB890X", + "18219": "AB890X", + "18220": "AB890X", + "18221": "AB890X", + "18222": "AB890X", + "18223": "AB890X", + "18224": "AB890X", + "18225": "AB890X", + "18229": "AB890X", + "18230": "AB890X", + "18231": "AB890X", + "18232": "AB890X", + "18234": "AB890X", + "18235": "AB890X", + "18237": "AB890X", + "18239": "AB890X", + "18240": "AB890X", + "18241": "AB890X", + "18242": "AB890X", + "18244": "AB890X", + "18245": "AB890X", + "18246": "AB890X", + "18247": "AB890X", + "18248": "AB890X", + "18249": "AB890X", + "18250": "AB890X", + "18251": "AB890X", + "18252": "AB890X", + "18254": "AB890X", + "18255": "AB890X", + "18256": "AB890X", + "18301": "AB890X", + "18302": "AB890X", + "18320": "AB890X", + "18321": "AB890X", + "18322": "AB890X", + "18323": "AB890X", + "18324": "AB890X", + "18325": "AB890X", + "18326": "AB890X", + "18327": "AB890X", + "18328": "AB890X", + "18330": "AB890X", + "18331": "AB890X", + "18332": "AB890X", + "18333": "AB890X", + "18334": "AB890X", + "18335": "AB890X", + "18336": "AB890X", + "18337": "AB890X", + "18340": "AB890X", + "18341": "AB890X", + "18342": "AB890X", + "18343": "AB890X", + "18344": "AB890X", + "18346": "AB890X", + "18347": "AB890X", + "18348": "AB890X", + "18349": "AB890X", + "18350": "AB890X", + "18351": "AB890X", + "18352": "AB890X", + "18353": "AB890X", + "18354": "AB890X", + "18355": "AB890X", + "18356": "AB890X", + "18357": "AB890X", + "18360": "AB890X", + "18370": "AB890X", + "18371": "AB890X", + "18372": "AB890X", + "18373": "AB890X", + "18403": "AB890X", + "18405": "AB890X", + "18407": "AB890X", + "18410": "AB890X", + "18411": "AB890X", + "18413": "AB890X", + "18414": "AB890X", + "18415": "AB890X", + "18416": "AB890X", + "18417": "AB890X", + "18419": "AB890X", + "18420": "AB890X", + "18421": "AB890X", + "18424": "AB890X", + "18425": "AB890X", + "18426": "AB890X", + "18427": "AB890X", + "18428": "AB890X", + "18430": "AB890X", + "18431": "AB890X", + "18433": "AB890X", + "18434": "AB890X", + "18435": "AB890X", + "18436": "AB890X", + "18437": "AB890X", + "18438": "AB890X", + "18439": "AB890X", + "18440": "AB890X", + "18441": "AB890X", + "18443": "AB890X", + "18444": "AB890X", + "18445": "AB890X", + "18446": "AB890X", + "18447": "AB890X", + "18448": "AB890X", + "18449": "AB890X", + "18451": "AB890X", + "18452": "AB890X", + "18453": "AB890X", + "18454": "AB890X", + "18455": "AB890X", + "18456": "AB890X", + "18457": "AB890X", + "18458": "AB890X", + "18459": "AB890X", + "18460": "AB890X", + "18461": "AB890X", + "18462": "AB890X", + "18463": "AB890X", + "18464": "AB890X", + "18465": "AB890X", + "18466": "AB890X", + "18469": "AB890X", + "18470": "AB890X", + "18471": "AB890X", + "18472": "AB890X", + "18473": "AB890X", + "18501": "AB890X", + "18502": "AB890X", + "18503": "AB890X", + "18504": "AB890X", + "18505": "AB890X", + "18507": "AB890X", + "18508": "AB890X", + "18509": "AB890X", + "18510": "AB890X", + "18512": "AB890X", + "18514": "AB890X", + "18515": "AB890X", + "18517": "AB890X", + "18518": "AB890X", + "18519": "AB890X", + "18522": "AB890X", + "18540": "AB890X", + "18577": "AB890X", + "18601": "AB890X", + "18602": "AB890X", + "18603": "AB890X", + "18610": "AB890X", + "18611": "AB890X", + "18612": "AB890X", + "18614": "AB890X", + "18615": "AB890X", + "18616": "AB890X", + "18617": "AB890X", + "18618": "AB890X", + "18619": "AB890X", + "18621": "AB890X", + "18622": "AB890X", + "18623": "AB890X", + "18624": "AB890X", + "18625": "AB890X", + "18626": "AB890X", + "18627": "AB890X", + "18628": "AB890X", + "18629": "AB890X", + "18630": "AB890X", + "18631": "AB890X", + "18632": "AB890X", + "18634": "AB890X", + "18635": "AB890X", + "18636": "AB890X", + "18640": "AB890X", + "18641": "AB890X", + "18642": "AB890X", + "18643": "AB890X", + "18644": "AB890X", + "18651": "AB890X", + "18653": "AB890X", + "18654": "AB890X", + "18655": "AB890X", + "18656": "AB890X", + "18657": "AB890X", + "18660": "AB890X", + "18661": "AB890X", + "18690": "AB890X", + "18701": "AB890X", + "18702": "AB890X", + "18703": "AB890X", + "18704": "AB890X", + "18705": "AB890X", + "18706": "AB890X", + "18707": "AB890X", + "18708": "AB890X", + "18709": "AB890X", + "18710": "AB890X", + "18711": "AB890X", + "18762": "AB890X", + "18764": "AB890X", + "18765": "AB890X", + "18766": "AB890X", + "18767": "AB890X", + "18769": "AB890X", + "18773": "AB890X", + "18801": "AB890X", + "18810": "AB890X", + "18812": "AB890X", + "18813": "AB890X", + "18814": "AB890X", + "18815": "AB890X", + "18816": "AB890X", + "18817": "AB890X", + "18818": "AB890X", + "18820": "AB890X", + "18821": "AB890X", + "18822": "AB890X", + "18823": "AB890X", + "18824": "AB890X", + "18825": "AB890X", + "18826": "AB890X", + "18827": "AB890X", + "18828": "AB890X", + "18829": "AB890X", + "18830": "AB890X", + "18831": "AB890X", + "18832": "AB890X", + "18833": "AB890X", + "18834": "AB890X", + "18837": "AB890X", + "18840": "AB890X", + "18842": "AB890X", + "18843": "AB890X", + "18844": "AB890X", + "18845": "AB890X", + "18846": "AB890X", + "18847": "AB890X", + "18848": "AB890X", + "18850": "AB890X", + "18851": "AB890X", + "18853": "AB890X", + "18854": "AB890X", + "18901": "AB890X", + "18902": "AB890X", + "18910": "AB890X", + "18911": "AB890X", + "18912": "AB890X", + "18913": "AB890X", + "18914": "AB890X", + "18915": "AB890X", + "18916": "AB890X", + "18917": "AB890X", + "18918": "AB890X", + "18920": "AB890X", + "18921": "AB890X", + "18922": "AB890X", + "18923": "AB890X", + "18924": "AB890X", + "18925": "AB890X", + "18926": "AB890X", + "18927": "AB890X", + "18928": "AB890X", + "18929": "AB890X", + "18930": "AB890X", + "18931": "AB890X", + "18932": "AB890X", + "18933": "AB890X", + "18934": "AB890X", + "18935": "AB890X", + "18936": "AB890X", + "18938": "AB890X", + "18940": "AB890X", + "18942": "AB890X", + "18943": "AB890X", + "18944": "AB890X", + "18946": "AB890X", + "18947": "AB890X", + "18949": "AB890X", + "18950": "AB890X", + "18951": "AB890X", + "18953": "AB890X", + "18954": "AB890X", + "18955": "AB890X", + "18956": "AB890X", + "18957": "AB890X", + "18958": "AB890X", + "18960": "AB890X", + "18962": "AB890X", + "18963": "AB890X", + "18964": "AB890X", + "18966": "AB890X", + "18968": "AB890X", + "18969": "AB890X", + "18970": "AB890X", + "18971": "AB890X", + "18972": "AB890X", + "18974": "AB890X", + "18976": "AB890X", + "18977": "AB890X", + "18979": "AB890X", + "18980": "AB890X", + "18981": "AB890X", + "18991": "AB890X", + "19001": "AB890X", + "19002": "AB890X", + "19003": "AB890X", + "19004": "AB890X", + "19006": "AB890X", + "19007": "AB890X", + "19008": "AB890X", + "19009": "AB890X", + "19010": "AB890X", + "19012": "AB890X", + "19013": "AB890X", + "19014": "AB890X", + "19015": "AB890X", + "19016": "AB890X", + "19017": "AB890X", + "19018": "AB890X", + "19019": "AB890X", + "19020": "AB890X", + "19021": "AB890X", + "19022": "AB890X", + "19023": "AB890X", + "19025": "AB890X", + "19026": "AB890X", + "19027": "AB890X", + "19028": "AB890X", + "19029": "AB890X", + "19030": "AB890X", + "19031": "AB890X", + "19032": "AB890X", + "19033": "AB890X", + "19034": "AB890X", + "19035": "AB890X", + "19036": "AB890X", + "19037": "AB890X", + "19038": "AB890X", + "19039": "AB890X", + "19040": "AB890X", + "19041": "AB890X", + "19043": "AB890X", + "19044": "AB890X", + "19046": "AB890X", + "19047": "AB890X", + "19048": "AB890X", + "19049": "AB890X", + "19050": "AB890X", + "19052": "AB890X", + "19053": "AB890X", + "19054": "AB890X", + "19055": "AB890X", + "19056": "AB890X", + "19057": "AB890X", + "19058": "AB890X", + "19061": "AB890X", + "19063": "AB890X", + "19064": "AB890X", + "19065": "AB890X", + "19066": "AB890X", + "19067": "AB890X", + "19070": "AB890X", + "19072": "AB890X", + "19073": "AB890X", + "19074": "AB890X", + "19075": "AB890X", + "19076": "AB890X", + "19078": "AB890X", + "19079": "AB890X", + "19080": "AB890X", + "19081": "AB890X", + "19082": "AB890X", + "19083": "AB890X", + "19085": "AB890X", + "19086": "AB890X", + "19087": "AB890X", + "19088": "AB890X", + "19089": "AB890X", + "19090": "AB890X", + "19091": "AB890X", + "19092": "AB890X", + "19093": "AB890X", + "19094": "AB890X", + "19095": "AB890X", + "19096": "AB890X", + "19098": "AB890X", + "19099": "AB890X", + "19101": "AB890X", + "19102": "AB890X", + "19103": "AB890X", + "19104": "AB890X", + "19105": "AB890X", + "19106": "AB890X", + "19107": "AB890X", + "19108": "AB890X", + "19109": "AB890X", + "19110": "AB890X", + "19111": "AB890X", + "19112": "AB890X", + "19113": "AB890X", + "19114": "AB890X", + "19115": "AB890X", + "19116": "AB890X", + "19118": "AB890X", + "19119": "AB890X", + "19120": "AB890X", + "19121": "AB890X", + "19122": "AB890X", + "19123": "AB890X", + "19124": "AB890X", + "19125": "AB890X", + "19126": "AB890X", + "19127": "AB890X", + "19128": "AB890X", + "19129": "AB890X", + "19130": "AB890X", + "19131": "AB890X", + "19132": "AB890X", + "19133": "AB890X", + "19134": "AB890X", + "19135": "AB890X", + "19136": "AB890X", + "19137": "AB890X", + "19138": "AB890X", + "19139": "AB890X", + "19140": "AB890X", + "19141": "AB890X", + "19142": "AB890X", + "19143": "AB890X", + "19144": "AB890X", + "19145": "AB890X", + "19146": "AB890X", + "19147": "AB890X", + "19148": "AB890X", + "19149": "AB890X", + "19150": "AB890X", + "19151": "AB890X", + "19152": "AB890X", + "19153": "AB890X", + "19154": "AB890X", + "19155": "AB890X", + "19160": "AB890X", + "19161": "AB890X", + "19162": "AB890X", + "19170": "AB890X", + "19171": "AB890X", + "19172": "AB890X", + "19173": "AB890X", + "19175": "AB890X", + "19176": "AB890X", + "19177": "AB890X", + "19178": "AB890X", + "19179": "AB890X", + "19181": "AB890X", + "19182": "AB890X", + "19183": "AB890X", + "19184": "AB890X", + "19185": "AB890X", + "19187": "AB890X", + "19188": "AB890X", + "19191": "AB890X", + "19192": "AB890X", + "19193": "AB890X", + "19194": "AB890X", + "19195": "AB890X", + "19196": "AB890X", + "19197": "AB890X", + "19244": "AB890X", + "19255": "AB890X", + "19301": "AB890X", + "19310": "AB890X", + "19311": "AB890X", + "19312": "AB890X", + "19316": "AB890X", + "19317": "AB890X", + "19318": "AB890X", + "19319": "AB890X", + "19320": "AB890X", + "19330": "AB890X", + "19331": "AB890X", + "19333": "AB890X", + "19335": "AB890X", + "19339": "AB890X", + "19340": "AB890X", + "19341": "AB890X", + "19342": "AB890X", + "19343": "AB890X", + "19344": "AB890X", + "19345": "AB890X", + "19346": "AB890X", + "19347": "AB890X", + "19348": "AB890X", + "19350": "AB890X", + "19351": "AB890X", + "19352": "AB890X", + "19353": "AB890X", + "19354": "AB890X", + "19355": "AB890X", + "19357": "AB890X", + "19358": "AB890X", + "19360": "AB890X", + "19362": "AB890X", + "19363": "AB890X", + "19365": "AB890X", + "19366": "AB890X", + "19367": "AB890X", + "19369": "AB890X", + "19371": "AB890X", + "19372": "AB890X", + "19373": "AB890X", + "19374": "AB890X", + "19375": "AB890X", + "19376": "AB890X", + "19380": "AB890X", + "19381": "AB890X", + "19382": "AB890X", + "19383": "AB890X", + "19390": "AB890X", + "19395": "AB890X", + "19397": "AB890X", + "19398": "AB890X", + "19399": "AB890X", + "19401": "AB890X", + "19403": "AB890X", + "19404": "AB890X", + "19405": "AB890X", + "19406": "AB890X", + "19407": "AB890X", + "19408": "AB890X", + "19409": "AB890X", + "19415": "AB890X", + "19420": "AB890X", + "19421": "AB890X", + "19422": "AB890X", + "19423": "AB890X", + "19424": "AB890X", + "19425": "AB890X", + "19426": "AB890X", + "19428": "AB890X", + "19429": "AB890X", + "19430": "AB890X", + "19432": "AB890X", + "19435": "AB890X", + "19436": "AB890X", + "19437": "AB890X", + "19438": "AB890X", + "19440": "AB890X", + "19441": "AB890X", + "19442": "AB890X", + "19443": "AB890X", + "19444": "AB890X", + "19446": "AB890X", + "19450": "AB890X", + "19451": "AB890X", + "19453": "AB890X", + "19454": "AB890X", + "19455": "AB890X", + "19456": "AB890X", + "19457": "AB890X", + "19460": "AB890X", + "19462": "AB890X", + "19464": "AB890X", + "19465": "AB887X", + "19468": "AB890X", + "19470": "AB890X", + "19472": "AB890X", + "19473": "AB890X", + "19474": "AB890X", + "19475": "AB890X", + "19477": "AB890X", + "19478": "AB890X", + "19479": "AB891X", + "19480": "AB890X", + "19481": "AB890X", + "19482": "AB890X", + "19483": "AB890X", + "19484": "AB890X", + "19485": "AB890X", + "19486": "AB890X", + "19487": "AB890X", + "19488": "AB890X", + "19489": "AB890X", + "19490": "AB890X", + "19492": "AB890X", + "19493": "AB890X", + "19494": "AB890X", + "19495": "AB890X", + "19496": "AB890X", + "19501": "AB892X", + "19503": "AB890X", + "19504": "AB890X", + "19505": "AB890X", + "19506": "AB890X", + "19507": "AB890X", + "19508": "AB890X", + "19510": "AB890X", + "19511": "AB890X", + "19512": "AB890X", + "19516": "AB890X", + "19518": "AB890X", + "19519": "AB890X", + "19520": "AB890X", + "19522": "AB890X", + "19523": "AB890X", + "19525": "AB890X", + "19526": "AB890X", + "19529": "AB890X", + "19530": "AB890X", + "19533": "AB890X", + "19534": "AB890X", + "19535": "AB890X", + "19536": "AB890X", + "19538": "AB890X", + "19539": "AB890X", + "19540": "AB890X", + "19541": "AB890X", + "19542": "AB890X", + "19543": "AB890X", + "19544": "AB890X", + "19545": "AB890X", + "19547": "AB890X", + "19548": "AB890X", + "19549": "AB890X", + "19550": "AB890X", + "19551": "AB890X", + "19554": "AB890X", + "19555": "AB890X", + "19559": "AB890X", + "19560": "AB890X", + "19562": "AB890X", + "19564": "AB890X", + "19565": "AB890X", + "19567": "AB890X", + "19601": "AB890X", + "19602": "AB890X", + "19603": "AB892X", + "19604": "AB890X", + "19605": "AB890X", + "19606": "AB890X", + "19607": "AB890X", + "19608": "AB890X", + "19609": "AB890X", + "19610": "AB890X", + "19611": "AB890X", + "19612": "AB890X", + "19640": "AB890X", + "19701": "AB890X", + "19702": "AB890X", + "19703": "AB890X", + "19706": "AB890X", + "19707": "AB890X", + "19708": "AB890X", + "19709": "AB890X", + "19710": "AB890X", + "19711": "AB890X", + "19712": "AB890X", + "19713": "AB890X", + "19714": "AB890X", + "19715": "AB890X", + "19716": "AB890X", + "19717": "AB890X", + "19718": "AB890X", + "19720": "AB890X", + "19721": "AB890X", + "19725": "AB890X", + "19726": "AB890X", + "19730": "AB890X", + "19731": "AB890X", + "19732": "AB890X", + "19733": "AB890X", + "19734": "AB890X", + "19735": "AB890X", + "19736": "AB890X", + "19801": "AB890X", + "19802": "AB890X", + "19803": "AB890X", + "19804": "AB890X", + "19805": "AB890X", + "19806": "AB890X", + "19807": "AB890X", + "19808": "AB890X", + "19809": "AB890X", + "19810": "AB890X", + "19850": "AB890X", + "19880": "AB890X", + "19884": "AB890X", + "19885": "AB890X", + "19886": "AB890X", + "19887": "AB890X", + "19889": "AB890X", + "19890": "AB890X", + "19891": "AB890X", + "19892": "AB890X", + "19893": "AB890X", + "19894": "AB890X", + "19895": "AB890X", + "19896": "AB890X", + "19897": "AB890X", + "19898": "AB890X", + "19899": "AB890X", + "19901": "AB890X", + "19902": "AB890X", + "19903": "AB890X", + "19904": "AB890X", + "19905": "AB890X", + "19906": "AB890X", + "19930": "AB890X", + "19931": "AB890X", + "19933": "AB890X", + "19934": "AB890X", + "19936": "AB890X", + "19938": "AB890X", + "19939": "AB890X", + "19940": "AB890X", + "19941": "AB890X", + "19943": "AB890X", + "19944": "AB890X", + "19945": "AB890X", + "19946": "AB890X", + "19947": "AB890X", + "19950": "AB890X", + "19951": "AB890X", + "19952": "AB890X", + "19953": "AB890X", + "19954": "AB890X", + "19955": "AB890X", + "19956": "AB890X", + "19958": "AB890X", + "19960": "AB890X", + "19961": "AB890X", + "19962": "AB890X", + "19963": "AB890X", + "19964": "AB890X", + "19966": "AB890X", + "19967": "AB890X", + "19968": "AB890X", + "19969": "AB890X", + "19970": "AB890X", + "19971": "AB890X", + "19973": "AB890X", + "19975": "AB890X", + "19977": "AB890X", + "19979": "AB890X", + "19980": "AB890X", + "20001": "AB892X", + "20002": "AB892X", + "20008": "AB892X", + "20011": "AB892X", + "20100": "AB890X", + "20101": "AB892X", + "20102": "AB892X", + "20103": "AB892X", + "20104": "AB892X", + "20105": "AB892X", + "20106": "AB892X", + "20107": "AB892X", + "20108": "AB892X", + "20109": "AB892X", + "20110": "AB892X", + "20111": "AB892X", + "20112": "AB892X", + "20113": "AB892X", + "20115": "AB892X", + "20116": "AB892X", + "20117": "AB892X", + "20118": "AB892X", + "20119": "AB892X", + "20120": "AB892X", + "20121": "AB892X", + "20122": "AB892X", + "20124": "AB892X", + "20128": "AB892X", + "20129": "AB892X", + "20130": "AB892X", + "20131": "AB892X", + "20132": "AB892X", + "20134": "AB892X", + "20135": "AB892X", + "20136": "AB892X", + "20137": "AB892X", + "20138": "AB892X", + "20139": "AB892X", + "20140": "AB892X", + "20141": "AB892X", + "20142": "AB892X", + "20143": "AB892X", + "20144": "AB892X", + "20146": "AB892X", + "20147": "AB892X", + "20148": "AB892X", + "20149": "AB892X", + "20151": "AB892X", + "20152": "AB892X", + "20153": "AB892X", + "20155": "AB892X", + "20156": "AB892X", + "20158": "AB892X", + "20159": "AB892X", + "20160": "AB892X", + "20163": "AB892X", + "20164": "AB892X", + "20165": "AB892X", + "20166": "AB892X", + "20167": "AB892X", + "20168": "AB892X", + "20169": "AB892X", + "20170": "AB892X", + "20171": "AB892X", + "20172": "AB892X", + "20175": "AB892X", + "20176": "AB892X", + "20177": "AB892X", + "20178": "AB892X", + "20180": "AB892X", + "20181": "AB892X", + "20182": "AB892X", + "20184": "AB892X", + "20185": "AB892X", + "20186": "AB892X", + "20187": "AB892X", + "20188": "AB892X", + "20189": "AB892X", + "20190": "AB892X", + "20191": "AB892X", + "20192": "AB892X", + "20193": "AB892X", + "20194": "AB892X", + "20195": "AB892X", + "20196": "AB892X", + "20197": "AB892X", + "20198": "AB892X", + "20199": "AB892X", + "20559": "AB892X", + "20601": "AB892X", + "20602": "AB892X", + "20603": "AB892X", + "20604": "AB892X", + "20606": "AB892X", + "20607": "AB892X", + "20608": "AB892X", + "20609": "AB892X", + "20610": "AB892X", + "20611": "AB892X", + "20612": "AB892X", + "20613": "AB892X", + "20615": "AB892X", + "20616": "AB892X", + "20617": "AB892X", + "20618": "AB892X", + "20619": "AB892X", + "20620": "AB892X", + "20621": "AB892X", + "20622": "AB892X", + "20623": "AB892X", + "20624": "AB892X", + "20625": "AB892X", + "20626": "AB892X", + "20627": "AB892X", + "20628": "AB892X", + "20629": "AB892X", + "20630": "AB892X", + "20632": "AB892X", + "20634": "AB892X", + "20635": "AB892X", + "20636": "AB892X", + "20637": "AB892X", + "20639": "AB892X", + "20640": "AB892X", + "20643": "AB892X", + "20645": "AB892X", + "20646": "AB892X", + "20650": "AB892X", + "20653": "AB892X", + "20656": "AB892X", + "20657": "AB892X", + "20658": "AB892X", + "20659": "AB892X", + "20660": "AB892X", + "20661": "AB892X", + "20662": "AB892X", + "20664": "AB892X", + "20667": "AB892X", + "20670": "AB892X", + "20674": "AB892X", + "20675": "AB892X", + "20676": "AB892X", + "20677": "AB892X", + "20678": "AB892X", + "20680": "AB892X", + "20682": "AB892X", + "20684": "AB892X", + "20685": "AB892X", + "20686": "AB892X", + "20687": "AB892X", + "20688": "AB892X", + "20689": "AB892X", + "20690": "AB892X", + "20692": "AB892X", + "20693": "AB892X", + "20695": "AB892X", + "20697": "AB892X", + "20701": "AB890X", + "20703": "AB892X", + "20704": "AB892X", + "20705": "AB892X", + "20706": "AB892X", + "20707": "AB892X", + "20708": "AB892X", + "20709": "AB892X", + "20710": "AB892X", + "20711": "AB890X", + "20712": "AB892X", + "20714": "AB892X", + "20715": "AB892X", + "20716": "AB892X", + "20717": "AB892X", + "20718": "AB892X", + "20719": "AB892X", + "20720": "AB892X", + "20721": "AB892X", + "20722": "AB892X", + "20723": "AB890X", + "20724": "AB890X", + "20725": "AB892X", + "20726": "AB892X", + "20731": "AB892X", + "20732": "AB892X", + "20733": "AB890X", + "20735": "AB892X", + "20736": "AB892X", + "20737": "AB892X", + "20738": "AB892X", + "20740": "AB892X", + "20741": "AB892X", + "20742": "AB892X", + "20743": "AB892X", + "20744": "AB892X", + "20745": "AB892X", + "20746": "AB892X", + "20747": "AB892X", + "20748": "AB892X", + "20749": "AB892X", + "20750": "AB892X", + "20751": "AB890X", + "20752": "AB892X", + "20753": "AB892X", + "20754": "AB892X", + "20755": "AB890X", + "20757": "AB892X", + "20758": "AB890X", + "20759": "AB890X", + "20762": "AB892X", + "20763": "AB890X", + "20764": "AB890X", + "20765": "AB890X", + "20768": "AB892X", + "20769": "AB892X", + "20770": "AB892X", + "20771": "AB892X", + "20772": "AB892X", + "20773": "AB892X", + "20774": "AB892X", + "20775": "AB892X", + "20776": "AB890X", + "20777": "AB890X", + "20778": "AB890X", + "20779": "AB890X", + "20781": "AB892X", + "20782": "AB892X", + "20783": "AB892X", + "20784": "AB892X", + "20785": "AB892X", + "20787": "AB892X", + "20788": "AB892X", + "20790": "AB892X", + "20791": "AB892X", + "20792": "AB892X", + "20794": "AB890X", + "20797": "AB892X", + "20799": "AB892X", + "20810": "AB892X", + "20811": "AB892X", + "20812": "AB892X", + "20813": "AB892X", + "20814": "AB892X", + "20815": "AB892X", + "20816": "AB892X", + "20817": "AB892X", + "20818": "AB892X", + "20824": "AB892X", + "20825": "AB892X", + "20827": "AB892X", + "20830": "AB892X", + "20832": "AB892X", + "20833": "AB892X", + "20837": "AB892X", + "20838": "AB892X", + "20839": "AB892X", + "20841": "AB892X", + "20842": "AB892X", + "20847": "AB892X", + "20848": "AB892X", + "20849": "AB892X", + "20850": "AB892X", + "20851": "AB892X", + "20852": "AB892X", + "20853": "AB892X", + "20854": "AB892X", + "20855": "AB892X", + "20857": "AB892X", + "20859": "AB892X", + "20860": "AB892X", + "20861": "AB892X", + "20862": "AB892X", + "20866": "AB892X", + "20868": "AB892X", + "20871": "AB892X", + "20872": "AB892X", + "20874": "AB892X", + "20875": "AB892X", + "20876": "AB892X", + "20877": "AB892X", + "20878": "AB892X", + "20879": "AB892X", + "20880": "AB892X", + "20882": "AB892X", + "20883": "AB892X", + "20884": "AB892X", + "20885": "AB892X", + "20886": "AB892X", + "20889": "AB892X", + "20891": "AB892X", + "20892": "AB892X", + "20894": "AB892X", + "20895": "AB892X", + "20896": "AB892X", + "20897": "AB892X", + "20898": "AB892X", + "20899": "AB892X", + "20901": "AB892X", + "20902": "AB892X", + "20903": "AB892X", + "20904": "AB892X", + "20905": "AB892X", + "20906": "AB892X", + "20907": "AB892X", + "20908": "AB892X", + "20910": "AB892X", + "20911": "AB892X", + "20912": "AB892X", + "20913": "AB892X", + "20914": "AB892X", + "20915": "AB892X", + "20916": "AB892X", + "20918": "AB892X", + "20993": "AB892X", + "20997": "AB892X", + "21001": "AB890X", + "21005": "AB890X", + "21009": "AB890X", + "21010": "AB890X", + "21012": "AB890X", + "21013": "AB890X", + "21014": "AB890X", + "21015": "AB890X", + "21017": "AB890X", + "21018": "AB890X", + "21020": "AB890X", + "21022": "AB890X", + "21023": "AB890X", + "21027": "AB890X", + "21028": "AB890X", + "21029": "AB890X", + "21030": "AB890X", + "21031": "AB890X", + "21032": "AB890X", + "21034": "AB890X", + "21035": "AB890X", + "21036": "AB890X", + "21037": "AB890X", + "21040": "AB890X", + "21041": "AB890X", + "21042": "AB890X", + "21043": "AB890X", + "21044": "AB890X", + "21045": "AB890X", + "21046": "AB890X", + "21047": "AB890X", + "21048": "AB890X", + "21050": "AB890X", + "21051": "AB890X", + "21052": "AB890X", + "21053": "AB890X", + "21054": "AB890X", + "21056": "AB890X", + "21057": "AB890X", + "21060": "AB890X", + "21061": "AB890X", + "21062": "AB890X", + "21065": "AB890X", + "21071": "AB890X", + "21074": "AB890X", + "21075": "AB890X", + "21076": "AB890X", + "21077": "AB890X", + "21078": "AB890X", + "21082": "AB890X", + "21084": "AB890X", + "21085": "AB890X", + "21087": "AB890X", + "21088": "AB890X", + "21090": "AB890X", + "21092": "AB890X", + "21093": "AB890X", + "21094": "AB890X", + "21098": "AB890X", + "21102": "AB890X", + "21104": "AB890X", + "21105": "AB890X", + "21106": "AB890X", + "21108": "AB890X", + "21111": "AB890X", + "21113": "AB890X", + "21114": "AB890X", + "21117": "AB890X", + "21120": "AB890X", + "21122": "AB890X", + "21123": "AB890X", + "21128": "AB890X", + "21130": "AB890X", + "21131": "AB890X", + "21132": "AB890X", + "21133": "AB890X", + "21136": "AB890X", + "21139": "AB890X", + "21140": "AB890X", + "21144": "AB890X", + "21146": "AB890X", + "21150": "AB890X", + "21152": "AB890X", + "21153": "AB890X", + "21154": "AB890X", + "21155": "AB890X", + "21156": "AB890X", + "21157": "AB890X", + "21158": "AB890X", + "21160": "AB890X", + "21161": "AB890X", + "21162": "AB890X", + "21163": "AB890X", + "21200": "AB890X", + "21201": "AB890X", + "21202": "AB890X", + "21203": "AB890X", + "21204": "AB890X", + "21205": "AB890X", + "21206": "AB890X", + "21207": "AB890X", + "21208": "AB890X", + "21209": "AB890X", + "21210": "AB890X", + "21211": "AB890X", + "21212": "AB890X", + "21213": "AB890X", + "21214": "AB890X", + "21215": "AB890X", + "21216": "AB890X", + "21217": "AB890X", + "21218": "AB890X", + "21219": "AB890X", + "21220": "AB890X", + "21221": "AB890X", + "21222": "AB890X", + "21223": "AB890X", + "21224": "AB890X", + "21225": "AB890X", + "21226": "AB890X", + "21227": "AB890X", + "21228": "AB890X", + "21229": "AB890X", + "21230": "AB890X", + "21231": "AB890X", + "21233": "AB890X", + "21234": "AB890X", + "21235": "AB890X", + "21236": "AB890X", + "21237": "AB890X", + "21239": "AB890X", + "21240": "AB890X", + "21241": "AB890X", + "21244": "AB890X", + "21250": "AB890X", + "21251": "AB890X", + "21252": "AB890X", + "21263": "AB890X", + "21264": "AB890X", + "21265": "AB890X", + "21268": "AB890X", + "21270": "AB890X", + "21273": "AB890X", + "21274": "AB890X", + "21275": "AB890X", + "21278": "AB890X", + "21279": "AB890X", + "21280": "AB890X", + "21281": "AB890X", + "21282": "AB890X", + "21283": "AB890X", + "21284": "AB890X", + "21285": "AB890X", + "21286": "AB890X", + "21287": "AB890X", + "21288": "AB890X", + "21289": "AB890X", + "21290": "AB890X", + "21297": "AB890X", + "21298": "AB890X", + "21400": "AB890X", + "21401": "AB890X", + "21402": "AB890X", + "21403": "AB890X", + "21404": "AB890X", + "21405": "AB890X", + "21409": "AB890X", + "21411": "AB890X", + "21412": "AB890X", + "21501": "AB892X", + "21502": "AB892X", + "21503": "AB892X", + "21504": "AB892X", + "21505": "AB892X", + "21520": "AB900X", + "21521": "AB892X", + "21522": "AB900X", + "21523": "AB900X", + "21524": "AB892X", + "21528": "AB892X", + "21529": "AB892X", + "21530": "AB892X", + "21531": "AB900X", + "21532": "AB892X", + "21536": "AB900X", + "21538": "AB900X", + "21539": "AB892X", + "21540": "AB892X", + "21541": "AB900X", + "21542": "AB892X", + "21543": "AB892X", + "21545": "AB892X", + "21550": "AB900X", + "21555": "AB892X", + "21556": "AB892X", + "21557": "AB892X", + "21560": "AB892X", + "21561": "AB900X", + "21562": "AB892X", + "21601": "AB890X", + "21606": "AB890X", + "21607": "AB890X", + "21609": "AB890X", + "21610": "AB890X", + "21612": "AB890X", + "21613": "AB890X", + "21617": "AB890X", + "21619": "AB890X", + "21620": "AB890X", + "21622": "AB890X", + "21623": "AB890X", + "21624": "AB890X", + "21625": "AB890X", + "21626": "AB890X", + "21627": "AB890X", + "21628": "AB890X", + "21629": "AB890X", + "21631": "AB890X", + "21632": "AB890X", + "21634": "AB890X", + "21635": "AB890X", + "21636": "AB890X", + "21637": "AB890X", + "21638": "AB890X", + "21639": "AB890X", + "21640": "AB890X", + "21641": "AB890X", + "21643": "AB890X", + "21644": "AB890X", + "21645": "AB890X", + "21647": "AB890X", + "21648": "AB890X", + "21649": "AB890X", + "21650": "AB890X", + "21651": "AB890X", + "21652": "AB890X", + "21653": "AB890X", + "21654": "AB890X", + "21655": "AB890X", + "21656": "AB890X", + "21657": "AB890X", + "21658": "AB890X", + "21659": "AB890X", + "21660": "AB890X", + "21661": "AB890X", + "21662": "AB890X", + "21663": "AB890X", + "21664": "AB890X", + "21665": "AB890X", + "21666": "AB890X", + "21667": "AB890X", + "21668": "AB890X", + "21669": "AB890X", + "21670": "AB890X", + "21671": "AB890X", + "21672": "AB890X", + "21673": "AB890X", + "21675": "AB890X", + "21676": "AB890X", + "21677": "AB890X", + "21678": "AB890X", + "21679": "AB890X", + "21681": "AB890X", + "21682": "AB890X", + "21683": "AB890X", + "21684": "AB890X", + "21685": "AB890X", + "21686": "AB890X", + "21687": "AB890X", + "21688": "AB890X", + "21690": "AB890X", + "21701": "AB892X", + "21702": "AB892X", + "21703": "AB892X", + "21704": "AB892X", + "21705": "AB892X", + "21709": "AB892X", + "21710": "AB892X", + "21711": "AB892X", + "21713": "AB892X", + "21714": "AB892X", + "21715": "AB892X", + "21716": "AB892X", + "21717": "AB892X", + "21718": "AB892X", + "21719": "AB892X", + "21720": "AB892X", + "21721": "AB892X", + "21722": "AB892X", + "21723": "AB890X", + "21727": "AB892X", + "21733": "AB892X", + "21734": "AB892X", + "21737": "AB890X", + "21738": "AB890X", + "21740": "AB892X", + "21741": "AB892X", + "21742": "AB892X", + "21746": "AB892X", + "21747": "AB892X", + "21748": "AB892X", + "21749": "AB892X", + "21750": "AB892X", + "21754": "AB892X", + "21755": "AB892X", + "21756": "AB892X", + "21757": "AB890X", + "21758": "AB892X", + "21759": "AB892X", + "21762": "AB892X", + "21765": "AB890X", + "21766": "AB892X", + "21767": "AB892X", + "21769": "AB892X", + "21770": "AB892X", + "21771": "AB892X", + "21773": "AB892X", + "21774": "AB892X", + "21775": "AB892X", + "21776": "AB890X", + "21777": "AB892X", + "21778": "AB892X", + "21779": "AB892X", + "21780": "AB892X", + "21781": "AB892X", + "21782": "AB892X", + "21783": "AB892X", + "21784": "AB890X", + "21787": "AB890X", + "21788": "AB892X", + "21790": "AB892X", + "21791": "AB890X", + "21792": "AB892X", + "21793": "AB892X", + "21794": "AB890X", + "21795": "AB892X", + "21797": "AB890X", + "21798": "AB892X", + "21801": "AB890X", + "21802": "AB890X", + "21803": "AB890X", + "21804": "AB890X", + "21810": "AB890X", + "21811": "AB890X", + "21813": "AB890X", + "21814": "AB890X", + "21817": "AB890X", + "21821": "AB890X", + "21822": "AB890X", + "21824": "AB890X", + "21826": "AB890X", + "21829": "AB890X", + "21830": "AB890X", + "21835": "AB890X", + "21836": "AB890X", + "21837": "AB890X", + "21838": "AB890X", + "21840": "AB890X", + "21841": "AB890X", + "21842": "AB890X", + "21843": "AB890X", + "21849": "AB890X", + "21850": "AB890X", + "21851": "AB890X", + "21852": "AB890X", + "21853": "AB890X", + "21856": "AB890X", + "21857": "AB890X", + "21861": "AB890X", + "21862": "AB890X", + "21863": "AB890X", + "21864": "AB890X", + "21865": "AB890X", + "21866": "AB890X", + "21867": "AB890X", + "21869": "AB890X", + "21871": "AB890X", + "21872": "AB890X", + "21874": "AB890X", + "21875": "AB890X", + "21890": "AB890X", + "21901": "AB890X", + "21902": "AB890X", + "21903": "AB890X", + "21904": "AB890X", + "21911": "AB890X", + "21912": "AB890X", + "21913": "AB890X", + "21914": "AB890X", + "21915": "AB890X", + "21916": "AB890X", + "21917": "AB890X", + "21918": "AB890X", + "21919": "AB890X", + "21920": "AB890X", + "21921": "AB890X", + "21922": "AB890X", + "21930": "AB890X", + "22003": "AB892X", + "22009": "AB892X", + "22015": "AB892X", + "22021": "AB887X", + "22025": "AB892X", + "22026": "AB892X", + "22027": "AB892X", + "22030": "AB892X", + "22031": "AB892X", + "22032": "AB892X", + "22033": "AB892X", + "22034": "AB892X", + "22035": "AB892X", + "22036": "AB892X", + "22037": "AB892X", + "22038": "AB892X", + "22039": "AB892X", + "22040": "AB892X", + "22041": "AB892X", + "22042": "AB892X", + "22043": "AB889X", + "22044": "AB892X", + "22046": "AB892X", + "22047": "AB892X", + "22060": "AB892X", + "22066": "AB892X", + "22067": "AB892X", + "22079": "AB892X", + "22081": "AB892X", + "22082": "AB892X", + "22092": "AB892X", + "22093": "AB892X", + "22095": "AB892X", + "22096": "AB892X", + "22101": "AB892X", + "22102": "AB892X", + "22103": "AB892X", + "22106": "AB892X", + "22107": "AB892X", + "22108": "AB892X", + "22109": "AB892X", + "22116": "AB892X", + "22118": "AB892X", + "22119": "AB892X", + "22120": "AB892X", + "22121": "AB892X", + "22122": "AB892X", + "22124": "AB892X", + "22125": "AB892X", + "22134": "AB892X", + "22135": "AB892X", + "22150": "AB892X", + "22151": "AB892X", + "22152": "AB892X", + "22153": "AB892X", + "22156": "AB892X", + "22158": "AB892X", + "22159": "AB892X", + "22160": "AB892X", + "22161": "AB892X", + "22172": "AB892X", + "22180": "AB890X", + "22181": "AB892X", + "22182": "AB892X", + "22183": "AB892X", + "22184": "AB892X", + "22185": "AB892X", + "22191": "AB892X", + "22192": "AB892X", + "22193": "AB892X", + "22194": "AB892X", + "22195": "AB892X", + "22199": "AB892X", + "22200": "AB890X", + "22201": "AB892X", + "22202": "AB892X", + "22203": "AB892X", + "22204": "AB892X", + "22205": "AB892X", + "22206": "AB892X", + "22207": "AB892X", + "22209": "AB892X", + "22210": "AB892X", + "22211": "AB892X", + "22212": "AB892X", + "22213": "AB892X", + "22214": "AB892X", + "22215": "AB892X", + "22216": "AB892X", + "22217": "AB892X", + "22218": "AB892X", + "22219": "AB892X", + "22222": "AB892X", + "22223": "AB892X", + "22225": "AB892X", + "22226": "AB892X", + "22227": "AB892X", + "22229": "AB892X", + "22230": "AB892X", + "22234": "AB892X", + "22240": "AB892X", + "22241": "AB892X", + "22242": "AB892X", + "22243": "AB892X", + "22244": "AB892X", + "22245": "AB892X", + "22246": "AB892X", + "22301": "AB892X", + "22302": "AB892X", + "22303": "AB892X", + "22304": "AB892X", + "22305": "AB892X", + "22306": "AB892X", + "22307": "AB892X", + "22308": "AB892X", + "22309": "AB892X", + "22310": "AB892X", + "22311": "AB892X", + "22312": "AB892X", + "22313": "AB892X", + "22314": "AB892X", + "22315": "AB892X", + "22320": "AB892X", + "22321": "AB892X", + "22331": "AB892X", + "22332": "AB892X", + "22333": "AB892X", + "22334": "AB892X", + "22336": "AB892X", + "22401": "AB892X", + "22402": "AB892X", + "22403": "AB892X", + "22404": "AB892X", + "22405": "AB892X", + "22406": "AB892X", + "22407": "AB892X", + "22408": "AB892X", + "22412": "AB892X", + "22427": "AB892X", + "22428": "AB892X", + "22430": "AB892X", + "22432": "AB892X", + "22433": "AB892X", + "22435": "AB892X", + "22436": "AB892X", + "22437": "AB892X", + "22438": "AB892X", + "22442": "AB892X", + "22443": "AB892X", + "22446": "AB892X", + "22448": "AB892X", + "22451": "AB892X", + "22454": "AB892X", + "22456": "AB892X", + "22460": "AB892X", + "22463": "AB892X", + "22469": "AB892X", + "22471": "AB892X", + "22472": "AB892X", + "22473": "AB892X", + "22476": "AB892X", + "22480": "AB892X", + "22481": "AB892X", + "22482": "AB892X", + "22485": "AB892X", + "22488": "AB892X", + "22501": "AB892X", + "22503": "AB892X", + "22504": "AB892X", + "22507": "AB892X", + "22508": "AB892X", + "22509": "AB892X", + "22511": "AB892X", + "22513": "AB892X", + "22514": "AB892X", + "22517": "AB892X", + "22520": "AB892X", + "22523": "AB892X", + "22524": "AB892X", + "22526": "AB892X", + "22528": "AB892X", + "22529": "AB892X", + "22530": "AB892X", + "22534": "AB892X", + "22535": "AB892X", + "22538": "AB892X", + "22539": "AB892X", + "22542": "AB892X", + "22544": "AB892X", + "22545": "AB892X", + "22546": "AB892X", + "22547": "AB892X", + "22548": "AB892X", + "22551": "AB892X", + "22552": "AB892X", + "22553": "AB892X", + "22554": "AB892X", + "22555": "AB892X", + "22556": "AB892X", + "22558": "AB892X", + "22560": "AB892X", + "22565": "AB892X", + "22567": "AB892X", + "22570": "AB892X", + "22572": "AB892X", + "22576": "AB892X", + "22577": "AB892X", + "22578": "AB892X", + "22579": "AB892X", + "22580": "AB892X", + "22581": "AB892X", + "22601": "AB892X", + "22602": "AB892X", + "22603": "AB892X", + "22604": "AB892X", + "22610": "AB892X", + "22611": "AB892X", + "22620": "AB892X", + "22622": "AB892X", + "22623": "AB892X", + "22624": "AB892X", + "22625": "AB892X", + "22626": "AB892X", + "22627": "AB892X", + "22630": "AB892X", + "22637": "AB892X", + "22638": "AB892X", + "22639": "AB892X", + "22640": "AB892X", + "22641": "AB892X", + "22642": "AB892X", + "22643": "AB892X", + "22644": "AB892X", + "22645": "AB892X", + "22646": "AB892X", + "22649": "AB892X", + "22650": "AB892X", + "22652": "AB892X", + "22654": "AB892X", + "22655": "AB892X", + "22656": "AB892X", + "22657": "AB892X", + "22660": "AB892X", + "22663": "AB892X", + "22664": "AB892X", + "22701": "AB892X", + "22709": "AB892X", + "22711": "AB892X", + "22712": "AB892X", + "22713": "AB892X", + "22714": "AB892X", + "22715": "AB892X", + "22716": "AB892X", + "22718": "AB892X", + "22719": "AB892X", + "22720": "AB892X", + "22721": "AB892X", + "22722": "AB892X", + "22723": "AB892X", + "22724": "AB892X", + "22725": "AB892X", + "22726": "AB892X", + "22727": "AB892X", + "22728": "AB892X", + "22729": "AB892X", + "22730": "AB892X", + "22731": "AB892X", + "22732": "AB892X", + "22733": "AB892X", + "22734": "AB892X", + "22735": "AB892X", + "22736": "AB892X", + "22737": "AB892X", + "22738": "AB892X", + "22739": "AB892X", + "22740": "AB892X", + "22741": "AB892X", + "22742": "AB892X", + "22743": "AB892X", + "22746": "AB892X", + "22747": "AB892X", + "22748": "AB892X", + "22749": "AB892X", + "22800": "AB890X", + "22801": "AB892X", + "22802": "AB892X", + "22803": "AB892X", + "22807": "AB892X", + "22810": "AB892X", + "22811": "AB892X", + "22812": "AB892X", + "22815": "AB892X", + "22820": "AB892X", + "22821": "AB892X", + "22824": "AB892X", + "22827": "AB892X", + "22830": "AB892X", + "22831": "AB892X", + "22832": "AB892X", + "22833": "AB892X", + "22834": "AB892X", + "22835": "AB892X", + "22840": "AB892X", + "22841": "AB892X", + "22842": "AB892X", + "22843": "AB892X", + "22844": "AB892X", + "22845": "AB892X", + "22846": "AB892X", + "22847": "AB892X", + "22848": "AB892X", + "22849": "AB892X", + "22850": "AB892X", + "22851": "AB892X", + "22853": "AB892X", + "22901": "AB892X", + "22902": "AB892X", + "22903": "AB892X", + "22904": "AB892X", + "22905": "AB892X", + "22906": "AB892X", + "22907": "AB892X", + "22908": "AB892X", + "22909": "AB892X", + "22910": "AB892X", + "22911": "AB892X", + "22920": "AB892X", + "22922": "AB892X", + "22923": "AB892X", + "22924": "AB892X", + "22931": "AB892X", + "22932": "AB892X", + "22935": "AB892X", + "22936": "AB892X", + "22937": "AB892X", + "22938": "AB892X", + "22939": "AB892X", + "22940": "AB892X", + "22942": "AB892X", + "22943": "AB892X", + "22945": "AB892X", + "22946": "AB892X", + "22947": "AB892X", + "22948": "AB892X", + "22949": "AB892X", + "22952": "AB892X", + "22957": "AB892X", + "22958": "AB892X", + "22959": "AB892X", + "22960": "AB892X", + "22963": "AB892X", + "22964": "AB892X", + "22965": "AB892X", + "22967": "AB892X", + "22968": "AB892X", + "22969": "AB892X", + "22971": "AB892X", + "22972": "AB892X", + "22973": "AB892X", + "22974": "AB892X", + "22976": "AB892X", + "22980": "AB892X", + "22987": "AB892X", + "22989": "AB892X", + "23001": "AB892X", + "23002": "AB892X", + "23003": "AB892X", + "23004": "AB892X", + "23005": "AB892X", + "23009": "AB892X", + "23011": "AB892X", + "23014": "AB892X", + "23015": "AB892X", + "23018": "AB892X", + "23021": "AB892X", + "23022": "AB892X", + "23023": "AB892X", + "23024": "AB892X", + "23025": "AB892X", + "23027": "AB892X", + "23030": "AB892X", + "23031": "AB892X", + "23032": "AB892X", + "23035": "AB892X", + "23038": "AB892X", + "23039": "AB892X", + "23040": "AB892X", + "23043": "AB892X", + "23045": "AB892X", + "23047": "AB892X", + "23050": "AB892X", + "23055": "AB892X", + "23056": "AB892X", + "23058": "AB892X", + "23059": "AB892X", + "23060": "AB892X", + "23061": "AB892X", + "23062": "AB892X", + "23063": "AB892X", + "23064": "AB892X", + "23065": "AB892X", + "23066": "AB892X", + "23067": "AB892X", + "23068": "AB892X", + "23069": "AB892X", + "23070": "AB892X", + "23071": "AB892X", + "23072": "AB892X", + "23075": "AB892X", + "23076": "AB892X", + "23079": "AB892X", + "23081": "AB892X", + "23083": "AB892X", + "23084": "AB892X", + "23085": "AB892X", + "23086": "AB892X", + "23089": "AB892X", + "23090": "AB892X", + "23091": "AB892X", + "23092": "AB892X", + "23093": "AB892X", + "23101": "AB892X", + "23102": "AB892X", + "23103": "AB892X", + "23105": "AB892X", + "23106": "AB892X", + "23107": "AB892X", + "23108": "AB892X", + "23109": "AB892X", + "23110": "AB892X", + "23111": "AB892X", + "23112": "AB892X", + "23113": "AB892X", + "23114": "AB892X", + "23115": "AB892X", + "23116": "AB892X", + "23117": "AB892X", + "23119": "AB892X", + "23120": "AB892X", + "23123": "AB892X", + "23124": "AB892X", + "23125": "AB892X", + "23126": "AB892X", + "23127": "AB892X", + "23128": "AB892X", + "23129": "AB892X", + "23130": "AB892X", + "23131": "AB892X", + "23138": "AB892X", + "23139": "AB892X", + "23140": "AB892X", + "23141": "AB892X", + "23146": "AB892X", + "23147": "AB892X", + "23148": "AB892X", + "23149": "AB892X", + "23150": "AB892X", + "23153": "AB892X", + "23154": "AB892X", + "23155": "AB892X", + "23156": "AB892X", + "23160": "AB892X", + "23161": "AB892X", + "23162": "AB892X", + "23163": "AB892X", + "23168": "AB892X", + "23169": "AB892X", + "23170": "AB892X", + "23173": "AB892X", + "23175": "AB892X", + "23176": "AB892X", + "23177": "AB892X", + "23178": "AB892X", + "23180": "AB892X", + "23181": "AB892X", + "23183": "AB892X", + "23184": "AB892X", + "23185": "AB892X", + "23186": "AB892X", + "23187": "AB892X", + "23188": "AB892X", + "23190": "AB892X", + "23192": "AB892X", + "23218": "AB892X", + "23219": "AB892X", + "23220": "AB892X", + "23221": "AB892X", + "23222": "AB892X", + "23223": "AB892X", + "23224": "AB892X", + "23225": "AB892X", + "23226": "AB892X", + "23227": "AB892X", + "23228": "AB892X", + "23229": "AB892X", + "23230": "AB892X", + "23231": "AB892X", + "23232": "AB892X", + "23233": "AB892X", + "23234": "AB892X", + "23235": "AB892X", + "23236": "AB892X", + "23237": "AB892X", + "23238": "AB892X", + "23240": "AB892X", + "23241": "AB892X", + "23242": "AB892X", + "23249": "AB892X", + "23250": "AB892X", + "23255": "AB892X", + "23260": "AB892X", + "23261": "AB892X", + "23269": "AB892X", + "23273": "AB892X", + "23274": "AB892X", + "23276": "AB892X", + "23278": "AB892X", + "23279": "AB892X", + "23282": "AB892X", + "23284": "AB892X", + "23285": "AB892X", + "23286": "AB892X", + "23288": "AB892X", + "23289": "AB892X", + "23290": "AB892X", + "23291": "AB892X", + "23292": "AB892X", + "23293": "AB892X", + "23294": "AB892X", + "23295": "AB892X", + "23297": "AB892X", + "23298": "AB892X", + "23301": "AB892X", + "23302": "AB892X", + "23303": "AB892X", + "23304": "AB892X", + "23306": "AB892X", + "23307": "AB892X", + "23308": "AB892X", + "23310": "AB892X", + "23313": "AB892X", + "23314": "AB892X", + "23315": "AB892X", + "23316": "AB892X", + "23320": "AB892X", + "23321": "AB892X", + "23322": "AB892X", + "23323": "AB892X", + "23324": "AB892X", + "23325": "AB892X", + "23326": "AB892X", + "23327": "AB892X", + "23328": "AB892X", + "23336": "AB892X", + "23337": "AB892X", + "23341": "AB892X", + "23345": "AB892X", + "23347": "AB892X", + "23350": "AB892X", + "23354": "AB892X", + "23356": "AB892X", + "23357": "AB892X", + "23358": "AB892X", + "23359": "AB892X", + "23389": "AB892X", + "23395": "AB892X", + "23396": "AB892X", + "23397": "AB892X", + "23398": "AB892X", + "23399": "AB892X", + "23401": "AB892X", + "23404": "AB892X", + "23405": "AB892X", + "23407": "AB892X", + "23408": "AB892X", + "23409": "AB892X", + "23410": "AB892X", + "23412": "AB892X", + "23413": "AB892X", + "23414": "AB892X", + "23415": "AB892X", + "23416": "AB892X", + "23417": "AB892X", + "23418": "AB892X", + "23419": "AB892X", + "23420": "AB892X", + "23421": "AB892X", + "23422": "AB892X", + "23423": "AB892X", + "23424": "AB892X", + "23426": "AB892X", + "23427": "AB892X", + "23429": "AB892X", + "23430": "AB892X", + "23431": "AB892X", + "23432": "AB892X", + "23433": "AB892X", + "23434": "AB892X", + "23435": "AB892X", + "23436": "AB892X", + "23437": "AB892X", + "23438": "AB892X", + "23439": "AB892X", + "23440": "AB892X", + "23441": "AB892X", + "23442": "AB892X", + "23443": "AB892X", + "23450": "AB892X", + "23451": "AB892X", + "23452": "AB892X", + "23453": "AB892X", + "23454": "AB892X", + "23455": "AB892X", + "23456": "AB892X", + "23457": "AB892X", + "23458": "AB892X", + "23459": "AB892X", + "23460": "AB892X", + "23461": "AB892X", + "23462": "AB892X", + "23463": "AB892X", + "23464": "AB892X", + "23465": "AB892X", + "23466": "AB892X", + "23467": "AB892X", + "23471": "AB892X", + "23479": "AB892X", + "23480": "AB892X", + "23482": "AB892X", + "23483": "AB892X", + "23486": "AB892X", + "23487": "AB892X", + "23488": "AB892X", + "23501": "AB892X", + "23502": "AB892X", + "23503": "AB892X", + "23504": "AB892X", + "23505": "AB892X", + "23506": "AB892X", + "23507": "AB892X", + "23508": "AB892X", + "23509": "AB892X", + "23510": "AB892X", + "23511": "AB892X", + "23512": "AB892X", + "23513": "AB892X", + "23514": "AB892X", + "23515": "AB892X", + "23517": "AB892X", + "23518": "AB892X", + "23519": "AB892X", + "23520": "AB892X", + "23521": "AB892X", + "23523": "AB892X", + "23529": "AB892X", + "23541": "AB892X", + "23551": "AB892X", + "23601": "AB892X", + "23602": "AB892X", + "23603": "AB892X", + "23604": "AB892X", + "23605": "AB892X", + "23606": "AB892X", + "23607": "AB892X", + "23608": "AB892X", + "23609": "AB892X", + "23612": "AB892X", + "23628": "AB892X", + "23630": "AB892X", + "23651": "AB892X", + "23661": "AB892X", + "23662": "AB892X", + "23663": "AB892X", + "23664": "AB892X", + "23665": "AB892X", + "23666": "AB892X", + "23667": "AB892X", + "23668": "AB892X", + "23669": "AB892X", + "23670": "AB892X", + "23681": "AB892X", + "23690": "AB892X", + "23691": "AB892X", + "23692": "AB892X", + "23693": "AB892X", + "23694": "AB892X", + "23696": "AB892X", + "23701": "AB892X", + "23702": "AB892X", + "23703": "AB892X", + "23704": "AB892X", + "23705": "AB892X", + "23707": "AB892X", + "23708": "AB892X", + "23709": "AB892X", + "23801": "AB892X", + "23803": "AB892X", + "23804": "AB892X", + "23805": "AB892X", + "23806": "AB892X", + "23821": "AB892X", + "23822": "AB892X", + "23824": "AB892X", + "23825": "AB892X", + "23827": "AB892X", + "23828": "AB892X", + "23829": "AB892X", + "23830": "AB892X", + "23831": "AB892X", + "23832": "AB892X", + "23833": "AB892X", + "23834": "AB892X", + "23836": "AB892X", + "23837": "AB892X", + "23838": "AB892X", + "23839": "AB892X", + "23840": "AB892X", + "23841": "AB892X", + "23842": "AB892X", + "23843": "AB892X", + "23844": "AB892X", + "23845": "AB892X", + "23846": "AB892X", + "23847": "AB892X", + "23850": "AB892X", + "23851": "AB892X", + "23856": "AB892X", + "23857": "AB892X", + "23860": "AB892X", + "23866": "AB892X", + "23867": "AB892X", + "23868": "AB892X", + "23870": "AB892X", + "23872": "AB892X", + "23873": "AB892X", + "23874": "AB892X", + "23875": "AB892X", + "23876": "AB892X", + "23878": "AB892X", + "23879": "AB892X", + "23881": "AB892X", + "23882": "AB892X", + "23883": "AB892X", + "23884": "AB892X", + "23885": "AB892X", + "23887": "AB892X", + "23888": "AB892X", + "23889": "AB892X", + "23890": "AB892X", + "23891": "AB892X", + "23893": "AB892X", + "23894": "AB892X", + "23897": "AB892X", + "23898": "AB892X", + "23899": "AB892X", + "23901": "AB892X", + "23909": "AB892X", + "23915": "AB892X", + "23917": "AB892X", + "23919": "AB892X", + "23920": "AB892X", + "23921": "AB892X", + "23922": "AB892X", + "23923": "AB892X", + "23924": "AB892X", + "23927": "AB892X", + "23930": "AB892X", + "23934": "AB892X", + "23936": "AB892X", + "23937": "AB892X", + "23938": "AB892X", + "23939": "AB892X", + "23941": "AB892X", + "23942": "AB892X", + "23943": "AB892X", + "23944": "AB892X", + "23947": "AB892X", + "23950": "AB892X", + "23952": "AB892X", + "23954": "AB892X", + "23955": "AB892X", + "23958": "AB892X", + "23959": "AB892X", + "23960": "AB892X", + "23962": "AB892X", + "23963": "AB892X", + "23964": "AB892X", + "23966": "AB892X", + "23967": "AB892X", + "23968": "AB892X", + "23970": "AB892X", + "23974": "AB892X", + "23976": "AB892X", + "24001": "AB892X", + "24002": "AB892X", + "24003": "AB892X", + "24004": "AB892X", + "24005": "AB892X", + "24006": "AB892X", + "24007": "AB892X", + "24008": "AB892X", + "24009": "AB892X", + "24010": "AB892X", + "24011": "AB892X", + "24012": "AB892X", + "24013": "AB892X", + "24014": "AB892X", + "24015": "AB892X", + "24016": "AB892X", + "24017": "AB892X", + "24018": "AB892X", + "24019": "AB892X", + "24020": "AB892X", + "24022": "AB892X", + "24023": "AB892X", + "24024": "AB892X", + "24025": "AB892X", + "24026": "AB892X", + "24027": "AB892X", + "24028": "AB892X", + "24029": "AB892X", + "24030": "AB892X", + "24031": "AB892X", + "24032": "AB892X", + "24033": "AB892X", + "24034": "AB892X", + "24035": "AB892X", + "24036": "AB892X", + "24037": "AB892X", + "24038": "AB892X", + "24040": "AB892X", + "24042": "AB892X", + "24043": "AB892X", + "24044": "AB892X", + "24045": "AB892X", + "24048": "AB892X", + "24050": "AB892X", + "24053": "AB887X", + "24054": "AB892X", + "24055": "AB892X", + "24058": "AB892X", + "24059": "AB892X", + "24060": "AB892X", + "24061": "AB892X", + "24062": "AB892X", + "24063": "AB892X", + "24064": "AB892X", + "24065": "AB892X", + "24066": "AB892X", + "24067": "AB892X", + "24068": "AB892X", + "24069": "AB892X", + "24070": "AB892X", + "24072": "AB892X", + "24073": "AB892X", + "24076": "AB887X", + "24077": "AB892X", + "24078": "AB892X", + "24079": "AB892X", + "24082": "AB892X", + "24083": "AB892X", + "24084": "AB892X", + "24085": "AB892X", + "24086": "AB892X", + "24087": "AB892X", + "24088": "AB892X", + "24089": "AB892X", + "24090": "AB892X", + "24091": "AB892X", + "24092": "AB892X", + "24093": "AB892X", + "24095": "AB892X", + "24101": "AB892X", + "24102": "AB892X", + "24104": "AB892X", + "24105": "AB892X", + "24111": "AB892X", + "24112": "AB892X", + "24113": "AB892X", + "24114": "AB892X", + "24115": "AB892X", + "24120": "AB892X", + "24121": "AB892X", + "24122": "AB892X", + "24124": "AB892X", + "24126": "AB892X", + "24127": "AB892X", + "24128": "AB892X", + "24129": "AB892X", + "24130": "AB892X", + "24131": "AB892X", + "24132": "AB892X", + "24133": "AB892X", + "24134": "AB892X", + "24136": "AB892X", + "24137": "AB892X", + "24138": "AB892X", + "24139": "AB892X", + "24141": "AB892X", + "24142": "AB892X", + "24143": "AB892X", + "24146": "AB892X", + "24147": "AB892X", + "24148": "AB892X", + "24149": "AB892X", + "24150": "AB892X", + "24151": "AB892X", + "24153": "AB892X", + "24155": "AB892X", + "24157": "AB892X", + "24161": "AB892X", + "24162": "AB892X", + "24165": "AB892X", + "24167": "AB892X", + "24168": "AB892X", + "24171": "AB887X", + "24174": "AB892X", + "24175": "AB892X", + "24176": "AB892X", + "24177": "AB892X", + "24178": "AB892X", + "24179": "AB892X", + "24184": "AB892X", + "24185": "AB892X", + "24201": "AB888X", + "24202": "AB888X", + "24203": "AB888X", + "24209": "AB888X", + "24210": "AB888X", + "24211": "AB888X", + "24212": "AB888X", + "24215": "AB888X", + "24216": "AB888X", + "24217": "AB892X", + "24218": "AB888X", + "24219": "AB888X", + "24220": "AB892X", + "24221": "AB888X", + "24224": "AB888X", + "24225": "AB888X", + "24226": "AB892X", + "24228": "AB892X", + "24230": "AB888X", + "24236": "AB888X", + "24237": "AB888X", + "24239": "AB900X", + "24243": "AB888X", + "24244": "AB888X", + "24245": "AB888X", + "24246": "AB888X", + "24248": "AB888X", + "24250": "AB888X", + "24251": "AB888X", + "24256": "AB892X", + "24258": "AB888X", + "24260": "AB888X", + "24263": "AB888X", + "24265": "AB888X", + "24266": "AB888X", + "24269": "AB892X", + "24270": "AB888X", + "24271": "AB888X", + "24272": "AB892X", + "24273": "AB888X", + "24274": "AB888X", + "24277": "AB888X", + "24279": "AB888X", + "24280": "AB888X", + "24281": "AB888X", + "24282": "AB888X", + "24283": "AB888X", + "24290": "AB888X", + "24292": "AB892X", + "24293": "AB888X", + "24301": "AB892X", + "24311": "AB888X", + "24312": "AB892X", + "24313": "AB892X", + "24314": "AB900X", + "24315": "AB900X", + "24316": "AB900X", + "24317": "AB887X", + "24318": "AB900X", + "24319": "AB888X", + "24322": "AB892X", + "24323": "AB892X", + "24324": "AB892X", + "24325": "AB892X", + "24326": "AB892X", + "24327": "AB888X", + "24328": "AB892X", + "24330": "AB892X", + "24333": "AB892X", + "24340": "AB888X", + "24343": "AB892X", + "24347": "AB892X", + "24348": "AB892X", + "24350": "AB892X", + "24351": "AB887X", + "24352": "AB892X", + "24354": "AB888X", + "24360": "AB892X", + "24361": "AB888X", + "24363": "AB892X", + "24366": "AB900X", + "24368": "AB892X", + "24370": "AB888X", + "24374": "AB892X", + "24375": "AB888X", + "24377": "AB900X", + "24378": "AB892X", + "24380": "AB892X", + "24381": "AB892X", + "24382": "AB892X", + "24401": "AB892X", + "24402": "AB892X", + "24411": "AB892X", + "24412": "AB892X", + "24413": "AB892X", + "24415": "AB892X", + "24416": "AB892X", + "24421": "AB892X", + "24422": "AB892X", + "24426": "AB892X", + "24430": "AB892X", + "24431": "AB892X", + "24432": "AB892X", + "24433": "AB892X", + "24435": "AB892X", + "24437": "AB892X", + "24438": "AB892X", + "24439": "AB892X", + "24440": "AB892X", + "24441": "AB892X", + "24442": "AB892X", + "24445": "AB892X", + "24448": "AB892X", + "24450": "AB892X", + "24457": "AB892X", + "24458": "AB892X", + "24459": "AB892X", + "24460": "AB892X", + "24463": "AB892X", + "24464": "AB892X", + "24465": "AB892X", + "24467": "AB892X", + "24468": "AB892X", + "24469": "AB892X", + "24471": "AB892X", + "24472": "AB892X", + "24473": "AB892X", + "24474": "AB892X", + "24475": "AB892X", + "24476": "AB892X", + "24477": "AB892X", + "24479": "AB892X", + "24482": "AB892X", + "24483": "AB892X", + "24484": "AB892X", + "24485": "AB892X", + "24486": "AB892X", + "24487": "AB892X", + "24501": "AB892X", + "24502": "AB892X", + "24503": "AB892X", + "24504": "AB892X", + "24505": "AB892X", + "24506": "AB892X", + "24512": "AB892X", + "24513": "AB892X", + "24514": "AB892X", + "24515": "AB892X", + "24517": "AB892X", + "24520": "AB892X", + "24521": "AB892X", + "24522": "AB892X", + "24523": "AB892X", + "24526": "AB892X", + "24527": "AB892X", + "24528": "AB892X", + "24529": "AB892X", + "24530": "AB892X", + "24531": "AB892X", + "24533": "AB892X", + "24534": "AB892X", + "24535": "AB892X", + "24536": "AB892X", + "24538": "AB892X", + "24539": "AB892X", + "24540": "AB892X", + "24541": "AB892X", + "24543": "AB888X", + "24544": "AB892X", + "24549": "AB892X", + "24550": "AB892X", + "24551": "AB892X", + "24553": "AB892X", + "24554": "AB892X", + "24555": "AB892X", + "24556": "AB892X", + "24557": "AB892X", + "24558": "AB892X", + "24562": "AB892X", + "24563": "AB892X", + "24565": "AB892X", + "24566": "AB892X", + "24569": "AB892X", + "24570": "AB892X", + "24571": "AB892X", + "24572": "AB892X", + "24574": "AB892X", + "24576": "AB892X", + "24577": "AB892X", + "24578": "AB892X", + "24579": "AB892X", + "24580": "AB892X", + "24581": "AB892X", + "24586": "AB892X", + "24588": "AB892X", + "24589": "AB892X", + "24590": "AB892X", + "24592": "AB892X", + "24593": "AB892X", + "24594": "AB892X", + "24595": "AB892X", + "24597": "AB892X", + "24598": "AB892X", + "24599": "AB892X", + "24601": "AB900X", + "24602": "AB900X", + "24603": "AB900X", + "24604": "AB900X", + "24605": "AB900X", + "24606": "AB900X", + "24607": "AB892X", + "24608": "AB900X", + "24609": "AB900X", + "24612": "AB900X", + "24613": "AB900X", + "24614": "AB900X", + "24619": "AB900X", + "24620": "AB900X", + "24622": "AB900X", + "24624": "AB900X", + "24627": "AB900X", + "24628": "AB900X", + "24630": "AB900X", + "24631": "AB900X", + "24634": "AB900X", + "24635": "AB900X", + "24637": "AB900X", + "24639": "AB900X", + "24640": "AB900X", + "24641": "AB900X", + "24646": "AB900X", + "24647": "AB900X", + "24649": "AB888X", + "24651": "AB900X", + "24656": "AB888X", + "24657": "AB900X", + "24658": "AB900X", + "24701": "AB900X", + "24712": "AB900X", + "24714": "AB900X", + "24715": "AB900X", + "24716": "AB900X", + "24719": "AB900X", + "24724": "AB900X", + "24726": "AB900X", + "24729": "AB900X", + "24731": "AB900X", + "24732": "AB900X", + "24733": "AB900X", + "24736": "AB900X", + "24737": "AB900X", + "24738": "AB900X", + "24739": "AB900X", + "24740": "AB900X", + "24747": "AB900X", + "24751": "AB900X", + "24801": "AB900X", + "24808": "AB900X", + "24811": "AB900X", + "24813": "AB900X", + "24815": "AB900X", + "24816": "AB900X", + "24817": "AB900X", + "24818": "AB900X", + "24821": "AB900X", + "24822": "AB900X", + "24823": "AB900X", + "24824": "AB900X", + "24825": "AB900X", + "24826": "AB900X", + "24827": "AB900X", + "24828": "AB900X", + "24829": "AB900X", + "24830": "AB900X", + "24831": "AB900X", + "24834": "AB900X", + "24836": "AB900X", + "24839": "AB900X", + "24842": "AB900X", + "24843": "AB900X", + "24844": "AB900X", + "24845": "AB900X", + "24846": "AB900X", + "24847": "AB900X", + "24848": "AB900X", + "24849": "AB900X", + "24850": "AB900X", + "24851": "AB900X", + "24852": "AB900X", + "24853": "AB900X", + "24854": "AB900X", + "24855": "AB900X", + "24857": "AB900X", + "24859": "AB900X", + "24860": "AB900X", + "24861": "AB900X", + "24862": "AB900X", + "24866": "AB900X", + "24867": "AB900X", + "24868": "AB900X", + "24869": "AB900X", + "24870": "AB900X", + "24871": "AB900X", + "24872": "AB900X", + "24873": "AB900X", + "24874": "AB900X", + "24877": "AB900X", + "24878": "AB900X", + "24879": "AB900X", + "24880": "AB900X", + "24881": "AB900X", + "24882": "AB900X", + "24884": "AB900X", + "24887": "AB900X", + "24888": "AB900X", + "24892": "AB900X", + "24894": "AB900X", + "24895": "AB900X", + "24898": "AB900X", + "24901": "AB900X", + "24902": "AB900X", + "24910": "AB900X", + "24915": "AB900X", + "24916": "AB900X", + "24917": "AB900X", + "24918": "AB900X", + "24920": "AB900X", + "24924": "AB900X", + "24925": "AB900X", + "24927": "AB900X", + "24931": "AB900X", + "24934": "AB900X", + "24935": "AB900X", + "24938": "AB900X", + "24941": "AB900X", + "24943": "AB900X", + "24944": "AB900X", + "24945": "AB900X", + "24946": "AB900X", + "24951": "AB900X", + "24954": "AB900X", + "24957": "AB900X", + "24961": "AB900X", + "24962": "AB900X", + "24963": "AB892X", + "24966": "AB900X", + "24970": "AB900X", + "24974": "AB900X", + "24976": "AB900X", + "24977": "AB900X", + "24981": "AB900X", + "24983": "AB900X", + "24984": "AB900X", + "24985": "AB900X", + "24986": "AB900X", + "24991": "AB900X", + "24993": "AB900X", + "25002": "AB900X", + "25003": "AB900X", + "25005": "AB900X", + "25007": "AB900X", + "25008": "AB900X", + "25009": "AB900X", + "25011": "AB900X", + "25015": "AB900X", + "25018": "AB900X", + "25019": "AB900X", + "25021": "AB900X", + "25022": "AB900X", + "25024": "AB900X", + "25025": "AB900X", + "25026": "AB900X", + "25028": "AB900X", + "25030": "AB900X", + "25031": "AB900X", + "25033": "AB900X", + "25035": "AB900X", + "25036": "AB900X", + "25039": "AB900X", + "25040": "AB900X", + "25043": "AB900X", + "25044": "AB900X", + "25045": "AB900X", + "25047": "AB900X", + "25048": "AB900X", + "25049": "AB900X", + "25051": "AB900X", + "25053": "AB900X", + "25054": "AB900X", + "25057": "AB900X", + "25059": "AB900X", + "25060": "AB900X", + "25061": "AB900X", + "25062": "AB900X", + "25063": "AB900X", + "25064": "AB900X", + "25067": "AB900X", + "25070": "AB900X", + "25071": "AB900X", + "25075": "AB900X", + "25076": "AB900X", + "25079": "AB900X", + "25081": "AB900X", + "25082": "AB900X", + "25083": "AB900X", + "25085": "AB900X", + "25086": "AB900X", + "25088": "AB900X", + "25090": "AB900X", + "25093": "AB900X", + "25102": "AB900X", + "25103": "AB900X", + "25106": "AB900X", + "25107": "AB900X", + "25108": "AB900X", + "25109": "AB900X", + "25110": "AB900X", + "25111": "AB900X", + "25112": "AB900X", + "25113": "AB900X", + "25114": "AB900X", + "25115": "AB900X", + "25118": "AB900X", + "25119": "AB900X", + "25121": "AB900X", + "25122": "AB900X", + "25123": "AB900X", + "25124": "AB900X", + "25125": "AB900X", + "25126": "AB900X", + "25130": "AB900X", + "25132": "AB900X", + "25133": "AB900X", + "25134": "AB900X", + "25136": "AB900X", + "25139": "AB900X", + "25140": "AB900X", + "25141": "AB900X", + "25142": "AB900X", + "25143": "AB900X", + "25147": "AB900X", + "25148": "AB900X", + "25149": "AB900X", + "25152": "AB900X", + "25154": "AB900X", + "25156": "AB900X", + "25159": "AB900X", + "25160": "AB900X", + "25161": "AB900X", + "25162": "AB900X", + "25164": "AB900X", + "25165": "AB900X", + "25168": "AB900X", + "25169": "AB900X", + "25173": "AB900X", + "25174": "AB900X", + "25177": "AB900X", + "25180": "AB900X", + "25181": "AB900X", + "25182": "AB900X", + "25183": "AB900X", + "25185": "AB900X", + "25186": "AB900X", + "25187": "AB900X", + "25193": "AB900X", + "25201": "AB900X", + "25202": "AB900X", + "25203": "AB900X", + "25204": "AB900X", + "25205": "AB900X", + "25206": "AB900X", + "25208": "AB900X", + "25209": "AB900X", + "25211": "AB900X", + "25213": "AB900X", + "25214": "AB900X", + "25231": "AB900X", + "25234": "AB900X", + "25235": "AB900X", + "25239": "AB900X", + "25241": "AB900X", + "25243": "AB900X", + "25244": "AB900X", + "25245": "AB900X", + "25247": "AB900X", + "25248": "AB900X", + "25251": "AB900X", + "25252": "AB900X", + "25253": "AB900X", + "25259": "AB900X", + "25260": "AB900X", + "25261": "AB900X", + "25262": "AB900X", + "25264": "AB900X", + "25265": "AB900X", + "25266": "AB900X", + "25267": "AB900X", + "25268": "AB900X", + "25270": "AB900X", + "25271": "AB900X", + "25275": "AB900X", + "25276": "AB900X", + "25285": "AB900X", + "25286": "AB900X", + "25287": "AB900X", + "25301": "AB900X", + "25302": "AB900X", + "25303": "AB900X", + "25304": "AB900X", + "25305": "AB900X", + "25306": "AB900X", + "25309": "AB900X", + "25311": "AB900X", + "25312": "AB900X", + "25313": "AB900X", + "25314": "AB900X", + "25315": "AB900X", + "25317": "AB900X", + "25320": "AB900X", + "25321": "AB900X", + "25322": "AB900X", + "25323": "AB900X", + "25324": "AB900X", + "25325": "AB900X", + "25326": "AB900X", + "25327": "AB900X", + "25328": "AB900X", + "25329": "AB900X", + "25330": "AB900X", + "25331": "AB900X", + "25332": "AB900X", + "25333": "AB900X", + "25334": "AB900X", + "25335": "AB900X", + "25336": "AB900X", + "25337": "AB900X", + "25338": "AB900X", + "25339": "AB900X", + "25350": "AB900X", + "25356": "AB900X", + "25357": "AB900X", + "25358": "AB900X", + "25360": "AB900X", + "25361": "AB900X", + "25362": "AB900X", + "25364": "AB900X", + "25365": "AB900X", + "25375": "AB900X", + "25387": "AB900X", + "25389": "AB900X", + "25392": "AB900X", + "25396": "AB900X", + "25401": "AB892X", + "25402": "AB892X", + "25403": "AB892X", + "25404": "AB892X", + "25405": "AB892X", + "25410": "AB892X", + "25411": "AB892X", + "25413": "AB892X", + "25414": "AB892X", + "25419": "AB892X", + "25420": "AB892X", + "25421": "AB892X", + "25422": "AB892X", + "25423": "AB892X", + "25425": "AB892X", + "25427": "AB892X", + "25428": "AB892X", + "25429": "AB892X", + "25430": "AB892X", + "25431": "AB892X", + "25432": "AB892X", + "25434": "AB892X", + "25437": "AB892X", + "25438": "AB892X", + "25440": "AB892X", + "25441": "AB892X", + "25442": "AB892X", + "25443": "AB892X", + "25444": "AB892X", + "25446": "AB892X", + "25501": "AB900X", + "25502": "AB900X", + "25503": "AB900X", + "25504": "AB900X", + "25505": "AB900X", + "25506": "AB900X", + "25507": "AB900X", + "25508": "AB900X", + "25510": "AB900X", + "25511": "AB900X", + "25512": "AB900X", + "25514": "AB900X", + "25515": "AB900X", + "25517": "AB900X", + "25520": "AB900X", + "25521": "AB900X", + "25523": "AB900X", + "25524": "AB900X", + "25526": "AB900X", + "25529": "AB900X", + "25530": "AB900X", + "25534": "AB900X", + "25535": "AB900X", + "25537": "AB900X", + "25540": "AB900X", + "25541": "AB900X", + "25544": "AB900X", + "25545": "AB900X", + "25547": "AB900X", + "25550": "AB900X", + "25555": "AB900X", + "25557": "AB900X", + "25559": "AB900X", + "25560": "AB900X", + "25562": "AB900X", + "25564": "AB900X", + "25565": "AB900X", + "25567": "AB900X", + "25569": "AB900X", + "25570": "AB900X", + "25571": "AB900X", + "25572": "AB900X", + "25573": "AB900X", + "25601": "AB900X", + "25606": "AB900X", + "25607": "AB900X", + "25608": "AB900X", + "25611": "AB900X", + "25612": "AB900X", + "25614": "AB900X", + "25617": "AB900X", + "25621": "AB900X", + "25624": "AB900X", + "25625": "AB900X", + "25628": "AB900X", + "25630": "AB900X", + "25632": "AB900X", + "25634": "AB900X", + "25635": "AB900X", + "25637": "AB900X", + "25638": "AB900X", + "25639": "AB900X", + "25644": "AB900X", + "25645": "AB900X", + "25646": "AB900X", + "25647": "AB900X", + "25649": "AB900X", + "25650": "AB900X", + "25651": "AB900X", + "25652": "AB900X", + "25653": "AB900X", + "25654": "AB900X", + "25661": "AB900X", + "25665": "AB900X", + "25666": "AB900X", + "25667": "AB900X", + "25669": "AB900X", + "25670": "AB900X", + "25671": "AB900X", + "25672": "AB900X", + "25674": "AB900X", + "25676": "AB900X", + "25678": "AB900X", + "25685": "AB900X", + "25686": "AB900X", + "25688": "AB900X", + "25690": "AB900X", + "25691": "AB900X", + "25692": "AB900X", + "25696": "AB900X", + "25697": "AB900X", + "25699": "AB900X", + "25701": "AB900X", + "25702": "AB900X", + "25703": "AB900X", + "25704": "AB900X", + "25705": "AB900X", + "25706": "AB900X", + "25707": "AB900X", + "25708": "AB900X", + "25709": "AB900X", + "25710": "AB900X", + "25711": "AB900X", + "25712": "AB900X", + "25713": "AB900X", + "25714": "AB900X", + "25715": "AB900X", + "25716": "AB900X", + "25717": "AB900X", + "25718": "AB900X", + "25719": "AB900X", + "25720": "AB900X", + "25721": "AB900X", + "25722": "AB900X", + "25723": "AB900X", + "25724": "AB900X", + "25725": "AB900X", + "25726": "AB900X", + "25727": "AB900X", + "25728": "AB900X", + "25729": "AB900X", + "25755": "AB900X", + "25770": "AB900X", + "25771": "AB900X", + "25772": "AB900X", + "25773": "AB900X", + "25774": "AB900X", + "25775": "AB900X", + "25776": "AB900X", + "25777": "AB900X", + "25778": "AB900X", + "25779": "AB900X", + "25801": "AB900X", + "25802": "AB900X", + "25810": "AB900X", + "25811": "AB900X", + "25812": "AB900X", + "25813": "AB900X", + "25816": "AB900X", + "25817": "AB900X", + "25818": "AB900X", + "25820": "AB900X", + "25823": "AB900X", + "25825": "AB900X", + "25826": "AB900X", + "25827": "AB900X", + "25831": "AB900X", + "25832": "AB900X", + "25833": "AB900X", + "25836": "AB900X", + "25837": "AB900X", + "25839": "AB900X", + "25840": "AB900X", + "25841": "AB900X", + "25843": "AB900X", + "25844": "AB900X", + "25845": "AB900X", + "25846": "AB900X", + "25848": "AB900X", + "25849": "AB900X", + "25851": "AB900X", + "25853": "AB900X", + "25854": "AB900X", + "25855": "AB900X", + "25857": "AB900X", + "25860": "AB900X", + "25862": "AB900X", + "25864": "AB900X", + "25865": "AB900X", + "25866": "AB900X", + "25868": "AB900X", + "25870": "AB900X", + "25871": "AB900X", + "25873": "AB900X", + "25875": "AB900X", + "25876": "AB900X", + "25878": "AB900X", + "25879": "AB900X", + "25880": "AB900X", + "25882": "AB900X", + "25901": "AB900X", + "25902": "AB900X", + "25904": "AB900X", + "25906": "AB900X", + "25907": "AB900X", + "25908": "AB900X", + "25909": "AB900X", + "25911": "AB900X", + "25913": "AB900X", + "25914": "AB900X", + "25915": "AB900X", + "25916": "AB900X", + "25917": "AB900X", + "25918": "AB900X", + "25919": "AB900X", + "25920": "AB900X", + "25921": "AB900X", + "25922": "AB900X", + "25926": "AB900X", + "25927": "AB900X", + "25928": "AB900X", + "25932": "AB900X", + "25936": "AB900X", + "25938": "AB900X", + "25942": "AB900X", + "25943": "AB900X", + "25951": "AB900X", + "25958": "AB900X", + "25961": "AB900X", + "25962": "AB900X", + "25965": "AB900X", + "25966": "AB900X", + "25969": "AB900X", + "25971": "AB900X", + "25972": "AB900X", + "25976": "AB900X", + "25977": "AB900X", + "25978": "AB900X", + "25979": "AB900X", + "25981": "AB900X", + "25984": "AB900X", + "25985": "AB900X", + "25986": "AB900X", + "25989": "AB900X", + "26003": "AB900X", + "26030": "AB900X", + "26031": "AB900X", + "26032": "AB900X", + "26033": "AB900X", + "26034": "AB900X", + "26035": "AB900X", + "26036": "AB900X", + "26037": "AB900X", + "26038": "AB900X", + "26039": "AB900X", + "26040": "AB900X", + "26041": "AB900X", + "26047": "AB900X", + "26050": "AB900X", + "26055": "AB900X", + "26056": "AB900X", + "26058": "AB900X", + "26059": "AB900X", + "26060": "AB900X", + "26062": "AB900X", + "26070": "AB900X", + "26074": "AB900X", + "26075": "AB900X", + "26101": "AB900X", + "26102": "AB900X", + "26103": "AB900X", + "26104": "AB900X", + "26105": "AB900X", + "26106": "AB900X", + "26120": "AB900X", + "26121": "AB900X", + "26133": "AB900X", + "26134": "AB900X", + "26136": "AB900X", + "26137": "AB900X", + "26138": "AB900X", + "26141": "AB900X", + "26142": "AB900X", + "26143": "AB900X", + "26146": "AB900X", + "26147": "AB900X", + "26148": "AB900X", + "26149": "AB900X", + "26150": "AB900X", + "26151": "AB900X", + "26152": "AB900X", + "26155": "AB900X", + "26159": "AB900X", + "26160": "AB900X", + "26161": "AB900X", + "26162": "AB900X", + "26164": "AB900X", + "26167": "AB900X", + "26169": "AB900X", + "26170": "AB900X", + "26175": "AB900X", + "26178": "AB900X", + "26180": "AB900X", + "26181": "AB900X", + "26184": "AB900X", + "26186": "AB900X", + "26187": "AB900X", + "26201": "AB900X", + "26202": "AB900X", + "26203": "AB900X", + "26205": "AB900X", + "26206": "AB900X", + "26208": "AB900X", + "26209": "AB900X", + "26210": "AB900X", + "26215": "AB900X", + "26217": "AB900X", + "26218": "AB900X", + "26219": "AB900X", + "26222": "AB900X", + "26224": "AB900X", + "26228": "AB900X", + "26229": "AB900X", + "26230": "AB900X", + "26234": "AB900X", + "26236": "AB900X", + "26237": "AB900X", + "26238": "AB900X", + "26241": "AB900X", + "26250": "AB900X", + "26253": "AB900X", + "26254": "AB900X", + "26257": "AB900X", + "26259": "AB900X", + "26260": "AB900X", + "26261": "AB900X", + "26263": "AB900X", + "26264": "AB900X", + "26266": "AB900X", + "26267": "AB900X", + "26268": "AB900X", + "26269": "AB900X", + "26270": "AB900X", + "26271": "AB900X", + "26273": "AB900X", + "26275": "AB900X", + "26276": "AB900X", + "26278": "AB900X", + "26280": "AB900X", + "26282": "AB900X", + "26283": "AB900X", + "26285": "AB900X", + "26287": "AB900X", + "26288": "AB900X", + "26289": "AB900X", + "26291": "AB900X", + "26292": "AB900X", + "26293": "AB900X", + "26294": "AB900X", + "26296": "AB900X", + "26298": "AB900X", + "26301": "AB900X", + "26302": "AB900X", + "26306": "AB900X", + "26320": "AB900X", + "26321": "AB900X", + "26323": "AB900X", + "26325": "AB900X", + "26327": "AB900X", + "26330": "AB900X", + "26335": "AB900X", + "26337": "AB900X", + "26338": "AB900X", + "26339": "AB900X", + "26342": "AB900X", + "26343": "AB900X", + "26346": "AB900X", + "26347": "AB900X", + "26348": "AB900X", + "26349": "AB900X", + "26351": "AB900X", + "26354": "AB900X", + "26361": "AB900X", + "26362": "AB900X", + "26366": "AB900X", + "26369": "AB900X", + "26372": "AB900X", + "26374": "AB900X", + "26376": "AB900X", + "26377": "AB900X", + "26378": "AB900X", + "26384": "AB900X", + "26385": "AB900X", + "26386": "AB900X", + "26401": "AB900X", + "26404": "AB900X", + "26405": "AB900X", + "26408": "AB900X", + "26410": "AB900X", + "26411": "AB900X", + "26412": "AB900X", + "26415": "AB900X", + "26416": "AB900X", + "26419": "AB900X", + "26421": "AB900X", + "26422": "AB900X", + "26424": "AB900X", + "26425": "AB900X", + "26426": "AB900X", + "26430": "AB900X", + "26431": "AB900X", + "26434": "AB900X", + "26435": "AB900X", + "26436": "AB900X", + "26437": "AB900X", + "26438": "AB900X", + "26440": "AB900X", + "26443": "AB900X", + "26444": "AB900X", + "26447": "AB900X", + "26448": "AB900X", + "26451": "AB900X", + "26452": "AB900X", + "26456": "AB900X", + "26461": "AB900X", + "26463": "AB900X", + "26501": "AB900X", + "26502": "AB900X", + "26504": "AB900X", + "26505": "AB900X", + "26506": "AB900X", + "26507": "AB900X", + "26508": "AB900X", + "26519": "AB900X", + "26520": "AB900X", + "26521": "AB900X", + "26524": "AB900X", + "26525": "AB900X", + "26527": "AB900X", + "26531": "AB900X", + "26534": "AB900X", + "26537": "AB900X", + "26541": "AB900X", + "26542": "AB900X", + "26543": "AB900X", + "26544": "AB900X", + "26546": "AB900X", + "26547": "AB900X", + "26554": "AB900X", + "26555": "AB887X", + "26559": "AB900X", + "26560": "AB900X", + "26561": "AB900X", + "26562": "AB900X", + "26563": "AB900X", + "26566": "AB900X", + "26568": "AB900X", + "26570": "AB900X", + "26571": "AB900X", + "26572": "AB900X", + "26574": "AB900X", + "26575": "AB900X", + "26576": "AB900X", + "26578": "AB900X", + "26581": "AB900X", + "26582": "AB900X", + "26585": "AB900X", + "26586": "AB900X", + "26587": "AB900X", + "26588": "AB900X", + "26589": "AB900X", + "26590": "AB900X", + "26591": "AB900X", + "26601": "AB900X", + "26610": "AB900X", + "26611": "AB900X", + "26615": "AB900X", + "26617": "AB900X", + "26619": "AB900X", + "26620": "AB900X", + "26621": "AB900X", + "26623": "AB900X", + "26624": "AB900X", + "26627": "AB900X", + "26629": "AB900X", + "26631": "AB900X", + "26636": "AB900X", + "26638": "AB900X", + "26639": "AB900X", + "26651": "AB900X", + "26656": "AB900X", + "26660": "AB900X", + "26662": "AB900X", + "26667": "AB900X", + "26671": "AB900X", + "26674": "AB900X", + "26675": "AB900X", + "26676": "AB900X", + "26678": "AB900X", + "26679": "AB900X", + "26680": "AB900X", + "26681": "AB900X", + "26683": "AB900X", + "26684": "AB900X", + "26690": "AB900X", + "26691": "AB900X", + "26704": "AB892X", + "26705": "AB900X", + "26707": "AB892X", + "26710": "AB892X", + "26711": "AB892X", + "26714": "AB892X", + "26716": "AB900X", + "26717": "AB892X", + "26719": "AB892X", + "26720": "AB892X", + "26722": "AB892X", + "26726": "AB892X", + "26731": "AB892X", + "26739": "AB892X", + "26743": "AB892X", + "26750": "AB892X", + "26753": "AB892X", + "26755": "AB892X", + "26757": "AB892X", + "26760": "AB900X", + "26761": "AB892X", + "26763": "AB892X", + "26764": "AB900X", + "26767": "AB892X", + "26801": "AB892X", + "26802": "AB900X", + "26804": "AB900X", + "26807": "AB900X", + "26808": "AB892X", + "26810": "AB892X", + "26812": "AB892X", + "26814": "AB900X", + "26815": "AB900X", + "26817": "AB892X", + "26818": "AB900X", + "26823": "AB892X", + "26833": "AB892X", + "26836": "AB892X", + "26838": "AB892X", + "26845": "AB892X", + "26847": "AB892X", + "26851": "AB892X", + "26852": "AB892X", + "26855": "AB900X", + "26865": "AB892X", + "26866": "AB900X", + "26884": "AB900X", + "26886": "AB900X", + "29001": "AB891X", + "29002": "AB891X", + "29003": "AB891X", + "29006": "AB891X", + "29009": "AB891X", + "29010": "AB891X", + "29014": "AB887X", + "29015": "AB891X", + "29016": "AB891X", + "29018": "AB891X", + "29020": "AB891X", + "29021": "AB891X", + "29030": "AB891X", + "29031": "AB895X", + "29032": "AB891X", + "29033": "AB891X", + "29036": "AB891X", + "29037": "AB895X", + "29038": "AB891X", + "29039": "AB891X", + "29040": "AB891X", + "29041": "AB891X", + "29042": "AB891X", + "29044": "AB891X", + "29045": "AB891X", + "29046": "AB891X", + "29047": "AB891X", + "29048": "AB891X", + "29051": "AB891X", + "29052": "AB891X", + "29053": "AB891X", + "29054": "AB891X", + "29055": "AB887X", + "29056": "AB891X", + "29058": "AB887X", + "29059": "AB891X", + "29061": "AB891X", + "29062": "AB891X", + "29063": "AB891X", + "29065": "AB891X", + "29067": "AB887X", + "29069": "AB888X", + "29070": "AB891X", + "29071": "AB891X", + "29072": "AB891X", + "29073": "AB891X", + "29074": "AB891X", + "29075": "AB891X", + "29078": "AB891X", + "29079": "AB891X", + "29080": "AB891X", + "29081": "AB891X", + "29082": "AB891X", + "29101": "AB891X", + "29102": "AB891X", + "29104": "AB891X", + "29105": "AB891X", + "29107": "AB891X", + "29108": "AB891X", + "29111": "AB891X", + "29112": "AB891X", + "29113": "AB891X", + "29114": "AB888X", + "29115": "AB891X", + "29116": "AB891X", + "29117": "AB891X", + "29118": "AB891X", + "29122": "AB891X", + "29123": "AB891X", + "29125": "AB891X", + "29126": "AB891X", + "29127": "AB891X", + "29128": "AB891X", + "29129": "AB891X", + "29130": "AB891X", + "29132": "AB891X", + "29133": "AB891X", + "29135": "AB891X", + "29137": "AB891X", + "29138": "AB895X", + "29142": "AB891X", + "29143": "AB891X", + "29145": "AB891X", + "29146": "AB891X", + "29147": "AB891X", + "29148": "AB891X", + "29150": "AB891X", + "29151": "AB891X", + "29152": "AB891X", + "29153": "AB891X", + "29154": "AB891X", + "29160": "AB891X", + "29161": "AB888X", + "29162": "AB891X", + "29163": "AB891X", + "29164": "AB891X", + "29166": "AB891X", + "29168": "AB891X", + "29169": "AB891X", + "29170": "AB891X", + "29171": "AB891X", + "29172": "AB891X", + "29175": "AB891X", + "29177": "AB891X", + "29178": "AB891X", + "29180": "AB891X", + "29201": "AB891X", + "29202": "AB891X", + "29203": "AB891X", + "29204": "AB891X", + "29205": "AB891X", + "29206": "AB891X", + "29207": "AB891X", + "29208": "AB891X", + "29209": "AB891X", + "29210": "AB891X", + "29211": "AB891X", + "29212": "AB891X", + "29214": "AB891X", + "29215": "AB891X", + "29216": "AB891X", + "29217": "AB891X", + "29218": "AB891X", + "29219": "AB891X", + "29220": "AB891X", + "29221": "AB891X", + "29222": "AB891X", + "29223": "AB891X", + "29224": "AB891X", + "29225": "AB891X", + "29226": "AB891X", + "29227": "AB891X", + "29228": "AB891X", + "29229": "AB891X", + "29230": "AB891X", + "29240": "AB891X", + "29250": "AB891X", + "29260": "AB891X", + "29290": "AB891X", + "29292": "AB891X", + "29301": "AB895X", + "29302": "AB895X", + "29303": "AB895X", + "29304": "AB895X", + "29305": "AB895X", + "29306": "AB895X", + "29307": "AB895X", + "29316": "AB895X", + "29318": "AB895X", + "29319": "AB895X", + "29320": "AB895X", + "29321": "AB895X", + "29322": "AB895X", + "29323": "AB895X", + "29324": "AB895X", + "29325": "AB895X", + "29329": "AB895X", + "29330": "AB895X", + "29331": "AB895X", + "29332": "AB895X", + "29333": "AB895X", + "29334": "AB895X", + "29335": "AB895X", + "29336": "AB895X", + "29338": "AB895X", + "29340": "AB895X", + "29341": "AB895X", + "29342": "AB895X", + "29346": "AB895X", + "29348": "AB895X", + "29349": "AB895X", + "29351": "AB895X", + "29353": "AB895X", + "29355": "AB891X", + "29356": "AB895X", + "29360": "AB895X", + "29364": "AB895X", + "29365": "AB895X", + "29368": "AB895X", + "29369": "AB895X", + "29370": "AB895X", + "29372": "AB895X", + "29373": "AB895X", + "29374": "AB895X", + "29375": "AB895X", + "29376": "AB895X", + "29377": "AB895X", + "29378": "AB895X", + "29379": "AB895X", + "29384": "AB895X", + "29385": "AB895X", + "29386": "AB895X", + "29388": "AB895X", + "29390": "AB895X", + "29391": "AB895X", + "29395": "AB895X", + "29401": "AB891X", + "29402": "AB891X", + "29403": "AB891X", + "29404": "AB891X", + "29405": "AB891X", + "29406": "AB891X", + "29407": "AB891X", + "29409": "AB891X", + "29410": "AB891X", + "29412": "AB891X", + "29413": "AB891X", + "29414": "AB891X", + "29415": "AB891X", + "29416": "AB891X", + "29417": "AB891X", + "29418": "AB891X", + "29419": "AB891X", + "29420": "AB891X", + "29422": "AB891X", + "29423": "AB891X", + "29424": "AB891X", + "29425": "AB891X", + "29426": "AB891X", + "29429": "AB891X", + "29430": "AB891X", + "29431": "AB891X", + "29432": "AB891X", + "29433": "AB891X", + "29434": "AB891X", + "29435": "AB891X", + "29436": "AB891X", + "29437": "AB891X", + "29438": "AB891X", + "29439": "AB891X", + "29440": "AB891X", + "29442": "AB891X", + "29445": "AB891X", + "29446": "AB891X", + "29447": "AB891X", + "29448": "AB891X", + "29449": "AB891X", + "29450": "AB891X", + "29451": "AB891X", + "29452": "AB891X", + "29453": "AB891X", + "29455": "AB891X", + "29456": "AB891X", + "29457": "AB891X", + "29458": "AB891X", + "29461": "AB891X", + "29464": "AB891X", + "29465": "AB891X", + "29466": "AB891X", + "29468": "AB891X", + "29469": "AB891X", + "29470": "AB891X", + "29471": "AB891X", + "29472": "AB891X", + "29474": "AB891X", + "29475": "AB891X", + "29476": "AB891X", + "29477": "AB891X", + "29479": "AB891X", + "29481": "AB891X", + "29482": "AB891X", + "29483": "AB891X", + "29484": "AB891X", + "29485": "AB891X", + "29486": "AB891X", + "29487": "AB891X", + "29488": "AB891X", + "29492": "AB891X", + "29493": "AB891X", + "29501": "AB888X", + "29502": "AB891X", + "29503": "AB891X", + "29504": "AB891X", + "29505": "AB888X", + "29506": "AB888X", + "29510": "AB891X", + "29511": "AB888X", + "29512": "AB888X", + "29516": "AB888X", + "29518": "AB888X", + "29519": "AB888X", + "29520": "AB887X", + "29525": "AB888X", + "29526": "AB888X", + "29527": "AB888X", + "29528": "AB888X", + "29530": "AB888X", + "29532": "AB888X", + "29536": "AB888X", + "29540": "AB888X", + "29541": "AB888X", + "29542": "AB888X", + "29543": "AB888X", + "29544": "AB888X", + "29545": "AB888X", + "29546": "AB888X", + "29547": "AB888X", + "29550": "AB888X", + "29551": "AB891X", + "29554": "AB888X", + "29555": "AB888X", + "29556": "AB888X", + "29560": "AB888X", + "29563": "AB888X", + "29564": "AB891X", + "29565": "AB888X", + "29566": "AB888X", + "29567": "AB888X", + "29568": "AB888X", + "29569": "AB888X", + "29570": "AB888X", + "29571": "AB888X", + "29572": "AB888X", + "29573": "AB888X", + "29574": "AB888X", + "29575": "AB888X", + "29576": "AB888X", + "29577": "AB888X", + "29578": "AB888X", + "29579": "AB888X", + "29580": "AB891X", + "29581": "AB888X", + "29582": "AB888X", + "29583": "AB888X", + "29584": "AB891X", + "29585": "AB888X", + "29587": "AB888X", + "29588": "AB888X", + "29589": "AB888X", + "29590": "AB891X", + "29591": "AB888X", + "29592": "AB888X", + "29593": "AB891X", + "29594": "AB888X", + "29596": "AB888X", + "29597": "AB888X", + "29598": "AB888X", + "29601": "AB895X", + "29602": "AB887X", + "29603": "AB895X", + "29604": "AB895X", + "29605": "AB895X", + "29606": "AB895X", + "29607": "AB895X", + "29608": "AB895X", + "29609": "AB895X", + "29610": "AB895X", + "29611": "AB895X", + "29612": "AB895X", + "29613": "AB895X", + "29614": "AB895X", + "29615": "AB895X", + "29616": "AB895X", + "29617": "AB895X", + "29620": "AB895X", + "29621": "AB895X", + "29622": "AB895X", + "29623": "AB895X", + "29624": "AB895X", + "29625": "AB895X", + "29626": "AB895X", + "29627": "AB895X", + "29628": "AB895X", + "29630": "AB895X", + "29631": "AB895X", + "29632": "AB895X", + "29633": "AB895X", + "29634": "AB895X", + "29635": "AB895X", + "29636": "AB895X", + "29638": "AB895X", + "29639": "AB895X", + "29640": "AB895X", + "29641": "AB895X", + "29642": "AB895X", + "29643": "AB895X", + "29644": "AB895X", + "29645": "AB895X", + "29646": "AB895X", + "29647": "AB895X", + "29648": "AB895X", + "29649": "AB895X", + "29650": "AB895X", + "29651": "AB895X", + "29652": "AB895X", + "29653": "AB895X", + "29654": "AB895X", + "29655": "AB895X", + "29656": "AB895X", + "29657": "AB895X", + "29658": "AB895X", + "29659": "AB895X", + "29661": "AB895X", + "29662": "AB895X", + "29664": "AB895X", + "29665": "AB895X", + "29666": "AB895X", + "29667": "AB895X", + "29669": "AB895X", + "29670": "AB895X", + "29671": "AB895X", + "29672": "AB895X", + "29673": "AB895X", + "29675": "AB895X", + "29676": "AB895X", + "29677": "AB895X", + "29678": "AB895X", + "29679": "AB895X", + "29680": "AB895X", + "29681": "AB895X", + "29682": "AB895X", + "29683": "AB895X", + "29684": "AB895X", + "29685": "AB895X", + "29686": "AB895X", + "29687": "AB895X", + "29688": "AB895X", + "29689": "AB895X", + "29690": "AB895X", + "29691": "AB895X", + "29692": "AB895X", + "29693": "AB895X", + "29695": "AB895X", + "29696": "AB895X", + "29697": "AB895X", + "29698": "AB895X", + "29702": "AB895X", + "29703": "AB887X", + "29704": "AB887X", + "29706": "AB887X", + "29707": "AB887X", + "29708": "AB887X", + "29709": "AB891X", + "29710": "AB887X", + "29712": "AB887X", + "29714": "AB887X", + "29715": "AB887X", + "29716": "AB887X", + "29717": "AB887X", + "29718": "AB887X", + "29720": "AB887X", + "29721": "AB891X", + "29722": "AB891X", + "29724": "AB887X", + "29726": "AB887X", + "29727": "AB891X", + "29728": "AB891X", + "29729": "AB887X", + "29730": "AB887X", + "29731": "AB887X", + "29732": "AB887X", + "29733": "AB887X", + "29734": "AB887X", + "29741": "AB891X", + "29742": "AB895X", + "29743": "AB887X", + "29744": "AB887X", + "29745": "AB887X", + "29801": "AB891X", + "29802": "AB891X", + "29803": "AB891X", + "29804": "AB891X", + "29805": "AB891X", + "29808": "AB891X", + "29809": "AB891X", + "29810": "AB891X", + "29812": "AB891X", + "29813": "AB891X", + "29816": "AB891X", + "29817": "AB891X", + "29819": "AB895X", + "29821": "AB895X", + "29822": "AB891X", + "29824": "AB891X", + "29826": "AB891X", + "29827": "AB891X", + "29828": "AB891X", + "29829": "AB891X", + "29831": "AB891X", + "29832": "AB891X", + "29834": "AB891X", + "29835": "AB895X", + "29836": "AB891X", + "29838": "AB895X", + "29839": "AB891X", + "29840": "AB895X", + "29841": "AB891X", + "29842": "AB891X", + "29843": "AB891X", + "29844": "AB895X", + "29845": "AB895X", + "29846": "AB891X", + "29847": "AB891X", + "29848": "AB895X", + "29849": "AB891X", + "29850": "AB891X", + "29851": "AB891X", + "29853": "AB891X", + "29856": "AB891X", + "29860": "AB891X", + "29861": "AB891X", + "29899": "AB895X", + "29901": "AB891X", + "29902": "AB891X", + "29903": "AB891X", + "29904": "AB891X", + "29905": "AB891X", + "29906": "AB891X", + "29907": "AB891X", + "29909": "AB891X", + "29910": "AB891X", + "29911": "AB891X", + "29912": "AB891X", + "29913": "AB891X", + "29914": "AB891X", + "29915": "AB891X", + "29916": "AB891X", + "29918": "AB891X", + "29920": "AB891X", + "29921": "AB891X", + "29922": "AB891X", + "29923": "AB891X", + "29924": "AB891X", + "29925": "AB891X", + "29926": "AB891X", + "29927": "AB891X", + "29928": "AB891X", + "29929": "AB891X", + "29931": "AB891X", + "29932": "AB891X", + "29933": "AB891X", + "29934": "AB891X", + "29935": "AB891X", + "29936": "AB891X", + "29938": "AB891X", + "29939": "AB891X", + "29940": "AB891X", + "29941": "AB891X", + "29943": "AB891X", + "29944": "AB891X", + "29945": "AB891X", + "30002": "AB889X", + "30003": "AB889X", + "30004": "AB889X", + "30005": "AB889X", + "30006": "AB889X", + "30007": "AB889X", + "30008": "AB889X", + "30009": "AB889X", + "30010": "AB889X", + "30011": "AB889X", + "30012": "AB889X", + "30013": "AB889X", + "30014": "AB889X", + "30015": "AB889X", + "30016": "AB889X", + "30017": "AB889X", + "30018": "AB889X", + "30019": "AB889X", + "30021": "AB889X", + "30022": "AB889X", + "30023": "AB889X", + "30024": "AB889X", + "30025": "AB889X", + "30026": "AB889X", + "30028": "AB889X", + "30029": "AB889X", + "30030": "AB889X", + "30031": "AB889X", + "30032": "AB889X", + "30033": "AB889X", + "30034": "AB889X", + "30035": "AB889X", + "30036": "AB889X", + "30037": "AB889X", + "30038": "AB889X", + "30039": "AB889X", + "30040": "AB889X", + "30041": "AB889X", + "30042": "AB889X", + "30043": "AB889X", + "30044": "AB889X", + "30045": "AB889X", + "30046": "AB889X", + "30047": "AB889X", + "30048": "AB889X", + "30049": "AB889X", + "30052": "AB889X", + "30054": "AB889X", + "30055": "AB889X", + "30056": "AB889X", + "30058": "AB889X", + "30060": "AB889X", + "30061": "AB889X", + "30062": "AB889X", + "30063": "AB889X", + "30064": "AB889X", + "30065": "AB889X", + "30066": "AB889X", + "30067": "AB889X", + "30068": "AB887X", + "30069": "AB889X", + "30070": "AB889X", + "30071": "AB889X", + "30072": "AB889X", + "30073": "AB889X", + "30074": "AB889X", + "30075": "AB889X", + "30076": "AB889X", + "30077": "AB889X", + "30078": "AB889X", + "30079": "AB889X", + "30080": "AB889X", + "30081": "AB889X", + "30082": "AB889X", + "30083": "AB889X", + "30084": "AB889X", + "30085": "AB889X", + "30086": "AB889X", + "30087": "AB889X", + "30088": "AB889X", + "30090": "AB889X", + "30091": "AB889X", + "30092": "AB889X", + "30093": "AB889X", + "30094": "AB889X", + "30095": "AB889X", + "30096": "AB889X", + "30097": "AB889X", + "30098": "AB889X", + "30099": "AB889X", + "30101": "AB889X", + "30102": "AB889X", + "30103": "AB889X", + "30104": "AB889X", + "30105": "AB889X", + "30106": "AB889X", + "30107": "AB889X", + "30108": "AB889X", + "30109": "AB889X", + "30110": "AB889X", + "30111": "AB889X", + "30112": "AB889X", + "30113": "AB889X", + "30114": "AB889X", + "30115": "AB889X", + "30116": "AB889X", + "30117": "AB889X", + "30118": "AB889X", + "30119": "AB889X", + "30120": "AB889X", + "30121": "AB889X", + "30122": "AB889X", + "30123": "AB889X", + "30124": "AB889X", + "30125": "AB889X", + "30126": "AB889X", + "30127": "AB889X", + "30129": "AB889X", + "30132": "AB889X", + "30133": "AB889X", + "30134": "AB889X", + "30135": "AB889X", + "30137": "AB889X", + "30138": "AB889X", + "30139": "AB889X", + "30140": "AB889X", + "30141": "AB889X", + "30142": "AB889X", + "30143": "AB889X", + "30144": "AB889X", + "30145": "AB889X", + "30146": "AB889X", + "30147": "AB889X", + "30148": "AB889X", + "30149": "AB889X", + "30150": "AB889X", + "30151": "AB889X", + "30152": "AB889X", + "30153": "AB889X", + "30154": "AB889X", + "30156": "AB889X", + "30157": "AB889X", + "30160": "AB889X", + "30161": "AB889X", + "30162": "AB889X", + "30163": "AB889X", + "30164": "AB889X", + "30165": "AB889X", + "30168": "AB889X", + "30169": "AB889X", + "30170": "AB889X", + "30171": "AB889X", + "30172": "AB889X", + "30173": "AB889X", + "30175": "AB889X", + "30176": "AB889X", + "30177": "AB889X", + "30178": "AB889X", + "30179": "AB889X", + "30180": "AB889X", + "30182": "AB889X", + "30183": "AB889X", + "30184": "AB889X", + "30185": "AB889X", + "30187": "AB889X", + "30188": "AB889X", + "30189": "AB889X", + "30204": "AB889X", + "30205": "AB889X", + "30206": "AB889X", + "30212": "AB889X", + "30213": "AB889X", + "30214": "AB889X", + "30215": "AB889X", + "30216": "AB889X", + "30217": "AB889X", + "30218": "AB889X", + "30219": "AB889X", + "30220": "AB889X", + "30222": "AB889X", + "30223": "AB889X", + "30224": "AB889X", + "30228": "AB889X", + "30229": "AB889X", + "30230": "AB889X", + "30233": "AB889X", + "30234": "AB889X", + "30236": "AB889X", + "30237": "AB889X", + "30238": "AB889X", + "30240": "AB889X", + "30241": "AB889X", + "30248": "AB889X", + "30250": "AB889X", + "30251": "AB889X", + "30252": "AB889X", + "30253": "AB889X", + "30256": "AB889X", + "30257": "AB889X", + "30258": "AB889X", + "30259": "AB889X", + "30260": "AB889X", + "30261": "AB889X", + "30263": "AB889X", + "30264": "AB889X", + "30265": "AB889X", + "30266": "AB889X", + "30268": "AB889X", + "30269": "AB889X", + "30270": "AB889X", + "30271": "AB889X", + "30272": "AB889X", + "30273": "AB889X", + "30274": "AB889X", + "30275": "AB889X", + "30276": "AB889X", + "30277": "AB889X", + "30281": "AB889X", + "30284": "AB889X", + "30285": "AB889X", + "30286": "AB889X", + "30287": "AB889X", + "30288": "AB889X", + "30289": "AB889X", + "30290": "AB889X", + "30291": "AB889X", + "30292": "AB889X", + "30293": "AB889X", + "30294": "AB889X", + "30295": "AB889X", + "30296": "AB889X", + "30297": "AB889X", + "30298": "AB889X", + "30301": "AB889X", + "30302": "AB889X", + "30303": "AB889X", + "30304": "AB889X", + "30305": "AB889X", + "30306": "AB889X", + "30307": "AB889X", + "30308": "AB889X", + "30309": "AB889X", + "30310": "AB889X", + "30311": "AB889X", + "30312": "AB889X", + "30313": "AB889X", + "30314": "AB889X", + "30315": "AB889X", + "30316": "AB889X", + "30317": "AB889X", + "30318": "AB889X", + "30319": "AB889X", + "30320": "AB889X", + "30321": "AB889X", + "30322": "AB889X", + "30324": "AB889X", + "30325": "AB889X", + "30326": "AB889X", + "30327": "AB889X", + "30328": "AB889X", + "30329": "AB889X", + "30330": "AB889X", + "30331": "AB889X", + "30332": "AB889X", + "30333": "AB889X", + "30334": "AB889X", + "30336": "AB889X", + "30337": "AB889X", + "30338": "AB889X", + "30339": "AB889X", + "30340": "AB889X", + "30341": "AB889X", + "30342": "AB889X", + "30343": "AB889X", + "30344": "AB889X", + "30345": "AB889X", + "30346": "AB889X", + "30347": "AB889X", + "30348": "AB889X", + "30349": "AB889X", + "30350": "AB889X", + "30353": "AB889X", + "30354": "AB889X", + "30355": "AB889X", + "30356": "AB889X", + "30357": "AB889X", + "30358": "AB889X", + "30359": "AB889X", + "30360": "AB889X", + "30361": "AB889X", + "30362": "AB889X", + "30363": "AB889X", + "30364": "AB889X", + "30366": "AB889X", + "30368": "AB889X", + "30369": "AB889X", + "30370": "AB889X", + "30371": "AB889X", + "30374": "AB889X", + "30375": "AB889X", + "30376": "AB889X", + "30377": "AB889X", + "30378": "AB889X", + "30379": "AB889X", + "30380": "AB889X", + "30384": "AB889X", + "30385": "AB889X", + "30386": "AB889X", + "30387": "AB889X", + "30388": "AB889X", + "30389": "AB889X", + "30390": "AB889X", + "30392": "AB889X", + "30394": "AB889X", + "30396": "AB889X", + "30398": "AB889X", + "30399": "AB889X", + "30401": "AB891X", + "30410": "AB891X", + "30411": "AB891X", + "30412": "AB891X", + "30413": "AB891X", + "30414": "AB891X", + "30415": "AB891X", + "30417": "AB891X", + "30420": "AB891X", + "30421": "AB891X", + "30423": "AB891X", + "30424": "AB891X", + "30425": "AB891X", + "30426": "AB891X", + "30427": "AB891X", + "30428": "AB891X", + "30429": "AB891X", + "30434": "AB891X", + "30436": "AB891X", + "30438": "AB891X", + "30439": "AB891X", + "30441": "AB891X", + "30442": "AB891X", + "30445": "AB891X", + "30446": "AB891X", + "30447": "AB891X", + "30448": "AB891X", + "30449": "AB891X", + "30450": "AB891X", + "30451": "AB891X", + "30452": "AB891X", + "30453": "AB891X", + "30454": "AB891X", + "30455": "AB891X", + "30456": "AB891X", + "30457": "AB891X", + "30458": "AB891X", + "30459": "AB891X", + "30460": "AB891X", + "30461": "AB891X", + "30464": "AB891X", + "30467": "AB891X", + "30470": "AB891X", + "30471": "AB891X", + "30473": "AB891X", + "30474": "AB891X", + "30475": "AB891X", + "30477": "AB891X", + "30499": "AB891X", + "30501": "AB889X", + "30502": "AB889X", + "30503": "AB889X", + "30504": "AB889X", + "30506": "AB889X", + "30507": "AB889X", + "30510": "AB889X", + "30511": "AB889X", + "30512": "AB889X", + "30513": "AB889X", + "30514": "AB889X", + "30515": "AB889X", + "30516": "AB895X", + "30517": "AB889X", + "30518": "AB889X", + "30519": "AB889X", + "30520": "AB895X", + "30521": "AB895X", + "30522": "AB889X", + "30523": "AB889X", + "30525": "AB889X", + "30527": "AB889X", + "30528": "AB889X", + "30529": "AB889X", + "30530": "AB889X", + "30531": "AB889X", + "30533": "AB889X", + "30534": "AB889X", + "30535": "AB889X", + "30536": "AB889X", + "30537": "AB889X", + "30538": "AB895X", + "30539": "AB889X", + "30540": "AB889X", + "30541": "AB889X", + "30542": "AB889X", + "30543": "AB889X", + "30544": "AB889X", + "30545": "AB889X", + "30546": "AB889X", + "30547": "AB889X", + "30548": "AB889X", + "30549": "AB889X", + "30552": "AB889X", + "30553": "AB895X", + "30554": "AB889X", + "30555": "AB888X", + "30557": "AB895X", + "30558": "AB889X", + "30559": "AB889X", + "30560": "AB889X", + "30562": "AB889X", + "30563": "AB889X", + "30564": "AB889X", + "30565": "AB889X", + "30566": "AB889X", + "30567": "AB889X", + "30568": "AB889X", + "30571": "AB889X", + "30572": "AB889X", + "30573": "AB889X", + "30575": "AB889X", + "30576": "AB889X", + "30577": "AB895X", + "30580": "AB889X", + "30581": "AB889X", + "30582": "AB889X", + "30596": "AB889X", + "30597": "AB889X", + "30598": "AB895X", + "30599": "AB889X", + "30601": "AB889X", + "30602": "AB889X", + "30603": "AB889X", + "30604": "AB889X", + "30605": "AB889X", + "30606": "AB889X", + "30607": "AB889X", + "30608": "AB889X", + "30609": "AB889X", + "30612": "AB889X", + "30619": "AB889X", + "30620": "AB889X", + "30621": "AB889X", + "30622": "AB889X", + "30623": "AB889X", + "30624": "AB895X", + "30625": "AB889X", + "30627": "AB895X", + "30628": "AB895X", + "30629": "AB895X", + "30630": "AB889X", + "30631": "AB889X", + "30633": "AB895X", + "30634": "AB895X", + "30635": "AB895X", + "30638": "AB889X", + "30639": "AB895X", + "30641": "AB889X", + "30642": "AB889X", + "30643": "AB895X", + "30645": "AB889X", + "30646": "AB895X", + "30647": "AB895X", + "30648": "AB889X", + "30650": "AB889X", + "30655": "AB889X", + "30656": "AB889X", + "30660": "AB895X", + "30662": "AB895X", + "30663": "AB889X", + "30664": "AB889X", + "30665": "AB889X", + "30666": "AB889X", + "30667": "AB889X", + "30668": "AB895X", + "30669": "AB889X", + "30671": "AB889X", + "30673": "AB895X", + "30677": "AB889X", + "30678": "AB889X", + "30680": "AB889X", + "30683": "AB889X", + "30701": "AB889X", + "30703": "AB889X", + "30705": "AB888X", + "30707": "AB888X", + "30708": "AB888X", + "30710": "AB888X", + "30711": "AB888X", + "30719": "AB888X", + "30720": "AB888X", + "30721": "AB888X", + "30722": "AB888X", + "30724": "AB888X", + "30725": "AB888X", + "30726": "AB888X", + "30728": "AB888X", + "30730": "AB888X", + "30731": "AB888X", + "30732": "AB889X", + "30733": "AB889X", + "30734": "AB889X", + "30735": "AB888X", + "30736": "AB888X", + "30738": "AB888X", + "30739": "AB888X", + "30740": "AB888X", + "30741": "AB888X", + "30742": "AB888X", + "30746": "AB889X", + "30747": "AB888X", + "30750": "AB888X", + "30751": "AB888X", + "30752": "AB888X", + "30753": "AB888X", + "30755": "AB888X", + "30756": "AB888X", + "30757": "AB888X", + "30802": "AB891X", + "30803": "AB891X", + "30805": "AB891X", + "30806": "AB891X", + "30807": "AB891X", + "30808": "AB891X", + "30809": "AB891X", + "30810": "AB891X", + "30811": "AB891X", + "30812": "AB891X", + "30813": "AB891X", + "30814": "AB891X", + "30815": "AB891X", + "30816": "AB891X", + "30817": "AB891X", + "30818": "AB891X", + "30819": "AB891X", + "30820": "AB891X", + "30821": "AB891X", + "30822": "AB891X", + "30823": "AB891X", + "30824": "AB891X", + "30828": "AB891X", + "30830": "AB891X", + "30833": "AB891X", + "30901": "AB891X", + "30903": "AB891X", + "30904": "AB891X", + "30905": "AB891X", + "30906": "AB891X", + "30907": "AB891X", + "30909": "AB891X", + "30911": "AB891X", + "30912": "AB891X", + "30913": "AB891X", + "30914": "AB891X", + "30916": "AB891X", + "30917": "AB891X", + "30919": "AB891X", + "30999": "AB891X", + "31001": "AB891X", + "31002": "AB891X", + "31003": "AB891X", + "31004": "AB891X", + "31005": "AB891X", + "31006": "AB890X", + "31007": "AB891X", + "31008": "AB891X", + "31009": "AB891X", + "31010": "AB891X", + "31011": "AB891X", + "31012": "AB891X", + "31013": "AB891X", + "31014": "AB891X", + "31015": "AB891X", + "31016": "AB891X", + "31017": "AB891X", + "31018": "AB891X", + "31019": "AB891X", + "31020": "AB891X", + "31021": "AB891X", + "31022": "AB891X", + "31023": "AB891X", + "31024": "AB889X", + "31025": "AB891X", + "31026": "AB889X", + "31027": "AB891X", + "31028": "AB891X", + "31029": "AB891X", + "31030": "AB891X", + "31031": "AB891X", + "31032": "AB891X", + "31033": "AB891X", + "31034": "AB891X", + "31035": "AB891X", + "31036": "AB891X", + "31037": "AB891X", + "31038": "AB891X", + "31039": "AB891X", + "31040": "AB891X", + "31041": "AB891X", + "31042": "AB891X", + "31044": "AB891X", + "31045": "AB891X", + "31046": "AB891X", + "31047": "AB891X", + "31049": "AB891X", + "31050": "AB891X", + "31051": "AB891X", + "31052": "AB891X", + "31054": "AB891X", + "31055": "AB891X", + "31057": "AB891X", + "31058": "AB890X", + "31059": "AB891X", + "31060": "AB891X", + "31061": "AB891X", + "31062": "AB891X", + "31063": "AB891X", + "31064": "AB891X", + "31065": "AB891X", + "31066": "AB891X", + "31067": "AB891X", + "31068": "AB891X", + "31069": "AB891X", + "31070": "AB891X", + "31071": "AB891X", + "31072": "AB891X", + "31075": "AB891X", + "31076": "AB891X", + "31077": "AB891X", + "31078": "AB891X", + "31079": "AB891X", + "31081": "AB891X", + "31082": "AB891X", + "31083": "AB891X", + "31084": "AB891X", + "31085": "AB889X", + "31086": "AB891X", + "31087": "AB891X", + "31088": "AB891X", + "31089": "AB891X", + "31090": "AB891X", + "31091": "AB891X", + "31092": "AB891X", + "31093": "AB891X", + "31094": "AB891X", + "31095": "AB891X", + "31096": "AB891X", + "31097": "AB889X", + "31098": "AB891X", + "31099": "AB891X", + "31106": "AB889X", + "31107": "AB889X", + "31119": "AB889X", + "31120": "AB889X", + "31126": "AB889X", + "31131": "AB889X", + "31136": "AB889X", + "31139": "AB889X", + "31141": "AB889X", + "31145": "AB889X", + "31146": "AB889X", + "31150": "AB889X", + "31156": "AB889X", + "31191": "AB889X", + "31192": "AB889X", + "31193": "AB889X", + "31195": "AB889X", + "31196": "AB889X", + "31197": "AB889X", + "31198": "AB889X", + "31199": "AB889X", + "31201": "AB891X", + "31202": "AB891X", + "31203": "AB891X", + "31204": "AB891X", + "31205": "AB891X", + "31206": "AB891X", + "31207": "AB891X", + "31208": "AB891X", + "31209": "AB891X", + "31210": "AB891X", + "31211": "AB891X", + "31212": "AB891X", + "31213": "AB891X", + "31216": "AB891X", + "31217": "AB891X", + "31220": "AB891X", + "31221": "AB891X", + "31255": "AB900X", + "31294": "AB891X", + "31295": "AB891X", + "31296": "AB891X", + "31297": "AB891X", + "31301": "AB891X", + "31302": "AB891X", + "31303": "AB891X", + "31304": "AB888X", + "31305": "AB888X", + "31307": "AB891X", + "31308": "AB891X", + "31309": "AB891X", + "31310": "AB891X", + "31312": "AB891X", + "31313": "AB891X", + "31314": "AB891X", + "31315": "AB891X", + "31316": "AB891X", + "31318": "AB891X", + "31319": "AB888X", + "31320": "AB891X", + "31321": "AB891X", + "31322": "AB891X", + "31323": "AB891X", + "31324": "AB891X", + "31326": "AB891X", + "31327": "AB888X", + "31328": "AB891X", + "31329": "AB891X", + "31331": "AB888X", + "31333": "AB891X", + "31401": "AB891X", + "31402": "AB891X", + "31403": "AB891X", + "31404": "AB891X", + "31405": "AB891X", + "31406": "AB891X", + "31407": "AB891X", + "31408": "AB891X", + "31409": "AB891X", + "31410": "AB891X", + "31411": "AB891X", + "31412": "AB891X", + "31414": "AB891X", + "31415": "AB891X", + "31416": "AB891X", + "31418": "AB891X", + "31419": "AB891X", + "31420": "AB891X", + "31421": "AB891X", + "31501": "AB888X", + "31502": "AB888X", + "31503": "AB888X", + "31510": "AB891X", + "31512": "AB891X", + "31513": "AB891X", + "31515": "AB891X", + "31516": "AB888X", + "31518": "AB888X", + "31519": "AB891X", + "31520": "AB888X", + "31521": "AB888X", + "31522": "AB888X", + "31523": "AB888X", + "31524": "AB888X", + "31525": "AB888X", + "31527": "AB888X", + "31532": "AB891X", + "31533": "AB891X", + "31534": "AB891X", + "31535": "AB891X", + "31537": "AB888X", + "31539": "AB891X", + "31542": "AB891X", + "31543": "AB888X", + "31544": "AB891X", + "31545": "AB891X", + "31546": "AB891X", + "31547": "AB888X", + "31548": "AB888X", + "31549": "AB891X", + "31550": "AB888X", + "31551": "AB888X", + "31552": "AB888X", + "31553": "AB888X", + "31554": "AB891X", + "31555": "AB891X", + "31556": "AB888X", + "31557": "AB891X", + "31558": "AB888X", + "31560": "AB891X", + "31561": "AB888X", + "31562": "AB888X", + "31563": "AB891X", + "31564": "AB888X", + "31565": "AB888X", + "31566": "AB888X", + "31567": "AB891X", + "31568": "AB888X", + "31569": "AB888X", + "31598": "AB891X", + "31599": "AB891X", + "31601": "AB891X", + "31602": "AB891X", + "31603": "AB891X", + "31604": "AB891X", + "31605": "AB891X", + "31606": "AB891X", + "31620": "AB891X", + "31622": "AB891X", + "31623": "AB891X", + "31624": "AB891X", + "31625": "AB891X", + "31626": "AB891X", + "31627": "AB891X", + "31629": "AB891X", + "31630": "AB891X", + "31631": "AB891X", + "31632": "AB891X", + "31634": "AB891X", + "31635": "AB891X", + "31636": "AB891X", + "31637": "AB891X", + "31638": "AB891X", + "31639": "AB891X", + "31641": "AB891X", + "31642": "AB891X", + "31643": "AB891X", + "31645": "AB891X", + "31647": "AB891X", + "31648": "AB891X", + "31649": "AB891X", + "31650": "AB891X", + "31698": "AB891X", + "31699": "AB891X", + "31701": "AB891X", + "31702": "AB891X", + "31703": "AB891X", + "31704": "AB891X", + "31705": "AB891X", + "31706": "AB891X", + "31707": "AB891X", + "31708": "AB891X", + "31709": "AB891X", + "31710": "AB891X", + "31711": "AB891X", + "31712": "AB891X", + "31714": "AB891X", + "31716": "AB891X", + "31719": "AB891X", + "31720": "AB891X", + "31721": "AB891X", + "31722": "AB891X", + "31723": "AB890X", + "31727": "AB891X", + "31730": "AB891X", + "31733": "AB891X", + "31735": "AB891X", + "31738": "AB891X", + "31739": "AB891X", + "31743": "AB891X", + "31744": "AB891X", + "31747": "AB891X", + "31749": "AB891X", + "31750": "AB891X", + "31753": "AB891X", + "31756": "AB891X", + "31757": "AB891X", + "31758": "AB891X", + "31760": "AB891X", + "31763": "AB891X", + "31764": "AB891X", + "31765": "AB891X", + "31768": "AB891X", + "31769": "AB891X", + "31771": "AB891X", + "31772": "AB891X", + "31773": "AB891X", + "31774": "AB891X", + "31775": "AB891X", + "31776": "AB891X", + "31778": "AB891X", + "31779": "AB891X", + "31780": "AB891X", + "31781": "AB891X", + "31782": "AB891X", + "31783": "AB891X", + "31784": "AB891X", + "31787": "AB891X", + "31788": "AB891X", + "31789": "AB891X", + "31790": "AB891X", + "31791": "AB891X", + "31792": "AB891X", + "31793": "AB891X", + "31794": "AB891X", + "31795": "AB891X", + "31796": "AB891X", + "31798": "AB891X", + "31799": "AB891X", + "31801": "AB890X", + "31803": "AB890X", + "31804": "AB890X", + "31805": "AB890X", + "31806": "AB891X", + "31807": "AB890X", + "31808": "AB890X", + "31810": "AB890X", + "31811": "AB890X", + "31812": "AB890X", + "31814": "AB890X", + "31815": "AB890X", + "31816": "AB890X", + "31820": "AB890X", + "31821": "AB890X", + "31822": "AB889X", + "31823": "AB890X", + "31824": "AB890X", + "31825": "AB890X", + "31826": "AB890X", + "31827": "AB890X", + "31829": "AB890X", + "31830": "AB890X", + "31831": "AB890X", + "31832": "AB890X", + "31833": "AB889X", + "31836": "AB890X", + "31901": "AB890X", + "31902": "AB890X", + "31903": "AB890X", + "31904": "AB890X", + "31905": "AB890X", + "31906": "AB890X", + "31907": "AB890X", + "31908": "AB890X", + "31909": "AB890X", + "31914": "AB890X", + "31917": "AB890X", + "31993": "AB890X", + "31995": "AB890X", + "31997": "AB890X", + "31998": "AB890X", + "31999": "AB890X", + "32003": "AB888X", + "32004": "AB888X", + "32006": "AB888X", + "32007": "AB888X", + "32008": "AB888X", + "32009": "AB888X", + "32011": "AB888X", + "32013": "AB888X", + "32024": "AB888X", + "32025": "AB888X", + "32026": "AB888X", + "32030": "AB888X", + "32033": "AB888X", + "32034": "AB888X", + "32035": "AB888X", + "32038": "AB888X", + "32040": "AB888X", + "32041": "AB888X", + "32042": "AB888X", + "32043": "AB888X", + "32044": "AB888X", + "32046": "AB888X", + "32050": "AB888X", + "32052": "AB888X", + "32053": "AB888X", + "32054": "AB888X", + "32055": "AB888X", + "32056": "AB888X", + "32058": "AB888X", + "32059": "AB891X", + "32060": "AB888X", + "32061": "AB888X", + "32062": "AB888X", + "32063": "AB888X", + "32064": "AB888X", + "32065": "AB888X", + "32066": "AB888X", + "32067": "AB888X", + "32068": "AB888X", + "32071": "AB888X", + "32072": "AB888X", + "32073": "AB888X", + "32079": "AB888X", + "32080": "AB888X", + "32081": "AB888X", + "32082": "AB888X", + "32083": "AB888X", + "32084": "AB888X", + "32085": "AB888X", + "32086": "AB888X", + "32087": "AB888X", + "32091": "AB888X", + "32092": "AB888X", + "32094": "AB888X", + "32095": "AB888X", + "32096": "AB888X", + "32097": "AB888X", + "32099": "AB888X", + "32102": "AB890X", + "32105": "AB890X", + "32110": "AB890X", + "32111": "AB890X", + "32112": "AB888X", + "32113": "AB890X", + "32114": "AB890X", + "32115": "AB890X", + "32116": "AB890X", + "32117": "AB890X", + "32118": "AB890X", + "32119": "AB890X", + "32120": "AB890X", + "32121": "AB890X", + "32122": "AB890X", + "32123": "AB890X", + "32124": "AB890X", + "32125": "AB890X", + "32126": "AB890X", + "32127": "AB890X", + "32128": "AB890X", + "32129": "AB890X", + "32130": "AB890X", + "32131": "AB888X", + "32132": "AB890X", + "32133": "AB890X", + "32134": "AB890X", + "32135": "AB890X", + "32136": "AB890X", + "32137": "AB890X", + "32138": "AB888X", + "32139": "AB888X", + "32140": "AB888X", + "32141": "AB890X", + "32142": "AB890X", + "32145": "AB888X", + "32147": "AB888X", + "32148": "AB888X", + "32149": "AB888X", + "32157": "AB888X", + "32158": "AB890X", + "32159": "AB890X", + "32160": "AB888X", + "32162": "AB890X", + "32163": "AB890X", + "32164": "AB890X", + "32168": "AB890X", + "32169": "AB890X", + "32170": "AB890X", + "32173": "AB890X", + "32174": "AB890X", + "32175": "AB890X", + "32176": "AB890X", + "32177": "AB888X", + "32178": "AB888X", + "32179": "AB890X", + "32180": "AB890X", + "32181": "AB888X", + "32182": "AB890X", + "32183": "AB890X", + "32185": "AB888X", + "32187": "AB888X", + "32189": "AB888X", + "32190": "AB890X", + "32192": "AB890X", + "32193": "AB888X", + "32195": "AB890X", + "32198": "AB890X", + "32201": "AB888X", + "32202": "AB888X", + "32203": "AB888X", + "32204": "AB888X", + "32205": "AB888X", + "32206": "AB888X", + "32207": "AB888X", + "32208": "AB888X", + "32209": "AB888X", + "32210": "AB888X", + "32211": "AB888X", + "32212": "AB888X", + "32214": "AB888X", + "32215": "AB888X", + "32216": "AB888X", + "32217": "AB888X", + "32218": "AB888X", + "32219": "AB888X", + "32220": "AB888X", + "32221": "AB888X", + "32222": "AB888X", + "32223": "AB888X", + "32224": "AB888X", + "32225": "AB888X", + "32226": "AB888X", + "32227": "AB888X", + "32228": "AB888X", + "32229": "AB888X", + "32230": "AB888X", + "32231": "AB888X", + "32232": "AB888X", + "32233": "AB888X", + "32234": "AB888X", + "32235": "AB888X", + "32236": "AB888X", + "32237": "AB888X", + "32238": "AB888X", + "32239": "AB888X", + "32240": "AB888X", + "32241": "AB888X", + "32244": "AB888X", + "32245": "AB888X", + "32246": "AB888X", + "32247": "AB888X", + "32250": "AB888X", + "32254": "AB888X", + "32255": "AB888X", + "32256": "AB888X", + "32257": "AB888X", + "32258": "AB888X", + "32259": "AB888X", + "32260": "AB888X", + "32266": "AB888X", + "32267": "AB888X", + "32277": "AB888X", + "32290": "AB888X", + "32301": "AB891X", + "32302": "AB891X", + "32303": "AB891X", + "32304": "AB891X", + "32305": "AB891X", + "32306": "AB891X", + "32307": "AB891X", + "32308": "AB891X", + "32309": "AB891X", + "32310": "AB891X", + "32311": "AB891X", + "32312": "AB891X", + "32313": "AB891X", + "32314": "AB891X", + "32315": "AB891X", + "32316": "AB891X", + "32317": "AB891X", + "32318": "AB891X", + "32320": "AB890X", + "32321": "AB891X", + "32322": "AB891X", + "32323": "AB891X", + "32324": "AB891X", + "32326": "AB891X", + "32327": "AB891X", + "32328": "AB891X", + "32329": "AB891X", + "32330": "AB891X", + "32331": "AB891X", + "32332": "AB891X", + "32333": "AB891X", + "32334": "AB891X", + "32335": "AB891X", + "32336": "AB891X", + "32337": "AB891X", + "32340": "AB891X", + "32341": "AB891X", + "32343": "AB891X", + "32344": "AB891X", + "32345": "AB891X", + "32346": "AB891X", + "32347": "AB891X", + "32348": "AB891X", + "32350": "AB891X", + "32351": "AB891X", + "32352": "AB891X", + "32353": "AB891X", + "32355": "AB891X", + "32356": "AB891X", + "32357": "AB891X", + "32358": "AB891X", + "32359": "AB891X", + "32360": "AB891X", + "32361": "AB891X", + "32362": "AB891X", + "32395": "AB891X", + "32399": "AB891X", + "32401": "AB890X", + "32402": "AB890X", + "32403": "AB890X", + "32404": "AB890X", + "32405": "AB890X", + "32406": "AB890X", + "32407": "AB890X", + "32408": "AB890X", + "32409": "AB890X", + "32410": "AB890X", + "32411": "AB890X", + "32412": "AB890X", + "32413": "AB890X", + "32417": "AB890X", + "32420": "AB890X", + "32421": "AB890X", + "32422": "AB890X", + "32423": "AB890X", + "32424": "AB890X", + "32425": "AB890X", + "32426": "AB890X", + "32427": "AB890X", + "32428": "AB890X", + "32430": "AB890X", + "32431": "AB890X", + "32432": "AB890X", + "32433": "AB890X", + "32434": "AB889X", + "32435": "AB890X", + "32437": "AB890X", + "32438": "AB890X", + "32439": "AB889X", + "32440": "AB890X", + "32442": "AB890X", + "32443": "AB890X", + "32444": "AB890X", + "32445": "AB890X", + "32446": "AB890X", + "32447": "AB890X", + "32448": "AB890X", + "32449": "AB890X", + "32452": "AB890X", + "32454": "AB890X", + "32455": "AB890X", + "32456": "AB890X", + "32457": "AB890X", + "32459": "AB889X", + "32460": "AB890X", + "32461": "AB890X", + "32462": "AB890X", + "32463": "AB890X", + "32464": "AB890X", + "32465": "AB890X", + "32466": "AB890X", + "32501": "AB889X", + "32502": "AB889X", + "32503": "AB889X", + "32504": "AB889X", + "32505": "AB889X", + "32506": "AB889X", + "32507": "AB889X", + "32508": "AB889X", + "32509": "AB889X", + "32511": "AB889X", + "32512": "AB889X", + "32513": "AB889X", + "32514": "AB889X", + "32516": "AB889X", + "32520": "AB889X", + "32521": "AB889X", + "32522": "AB889X", + "32523": "AB889X", + "32524": "AB889X", + "32526": "AB889X", + "32530": "AB889X", + "32531": "AB889X", + "32533": "AB889X", + "32534": "AB889X", + "32535": "AB889X", + "32536": "AB889X", + "32537": "AB889X", + "32538": "AB890X", + "32539": "AB889X", + "32540": "AB889X", + "32541": "AB889X", + "32542": "AB889X", + "32544": "AB889X", + "32547": "AB889X", + "32548": "AB889X", + "32549": "AB889X", + "32550": "AB889X", + "32559": "AB889X", + "32560": "AB889X", + "32561": "AB889X", + "32562": "AB889X", + "32563": "AB889X", + "32564": "AB889X", + "32565": "AB889X", + "32566": "AB889X", + "32567": "AB889X", + "32568": "AB889X", + "32569": "AB889X", + "32570": "AB889X", + "32571": "AB889X", + "32572": "AB889X", + "32574": "AB889X", + "32577": "AB889X", + "32578": "AB889X", + "32579": "AB889X", + "32580": "AB889X", + "32583": "AB889X", + "32588": "AB889X", + "32590": "AB889X", + "32591": "AB889X", + "32592": "AB889X", + "32601": "AB888X", + "32602": "AB888X", + "32603": "AB888X", + "32604": "AB888X", + "32605": "AB888X", + "32606": "AB888X", + "32607": "AB888X", + "32608": "AB888X", + "32609": "AB888X", + "32610": "AB888X", + "32611": "AB888X", + "32612": "AB888X", + "32613": "AB888X", + "32614": "AB888X", + "32615": "AB888X", + "32616": "AB888X", + "32617": "AB890X", + "32618": "AB888X", + "32619": "AB888X", + "32621": "AB888X", + "32622": "AB888X", + "32625": "AB888X", + "32626": "AB888X", + "32627": "AB888X", + "32628": "AB888X", + "32631": "AB888X", + "32633": "AB888X", + "32634": "AB890X", + "32635": "AB888X", + "32639": "AB888X", + "32640": "AB888X", + "32641": "AB888X", + "32643": "AB888X", + "32644": "AB888X", + "32648": "AB888X", + "32653": "AB888X", + "32654": "AB888X", + "32655": "AB888X", + "32656": "AB888X", + "32658": "AB888X", + "32662": "AB888X", + "32663": "AB890X", + "32664": "AB888X", + "32666": "AB888X", + "32667": "AB888X", + "32668": "AB888X", + "32669": "AB888X", + "32680": "AB888X", + "32681": "AB890X", + "32683": "AB888X", + "32686": "AB890X", + "32692": "AB888X", + "32693": "AB888X", + "32694": "AB888X", + "32696": "AB888X", + "32697": "AB888X", + "32701": "AB890X", + "32702": "AB890X", + "32703": "AB890X", + "32704": "AB890X", + "32706": "AB890X", + "32707": "AB890X", + "32708": "AB890X", + "32709": "AB890X", + "32710": "AB890X", + "32712": "AB890X", + "32713": "AB890X", + "32714": "AB890X", + "32715": "AB890X", + "32716": "AB890X", + "32718": "AB890X", + "32719": "AB890X", + "32720": "AB890X", + "32721": "AB890X", + "32722": "AB890X", + "32723": "AB890X", + "32724": "AB890X", + "32725": "AB890X", + "32726": "AB890X", + "32727": "AB890X", + "32728": "AB890X", + "32730": "AB890X", + "32732": "AB890X", + "32733": "AB890X", + "32735": "AB890X", + "32736": "AB890X", + "32738": "AB890X", + "32739": "AB890X", + "32744": "AB890X", + "32745": "AB890X", + "32746": "AB890X", + "32747": "AB890X", + "32750": "AB890X", + "32751": "AB890X", + "32752": "AB890X", + "32753": "AB890X", + "32754": "AB890X", + "32756": "AB890X", + "32757": "AB890X", + "32759": "AB890X", + "32762": "AB890X", + "32763": "AB890X", + "32764": "AB890X", + "32765": "AB890X", + "32766": "AB890X", + "32767": "AB890X", + "32768": "AB890X", + "32771": "AB890X", + "32772": "AB890X", + "32773": "AB890X", + "32774": "AB890X", + "32775": "AB890X", + "32776": "AB890X", + "32777": "AB890X", + "32778": "AB890X", + "32779": "AB890X", + "32780": "AB890X", + "32781": "AB890X", + "32782": "AB890X", + "32783": "AB890X", + "32784": "AB890X", + "32789": "AB890X", + "32790": "AB890X", + "32791": "AB890X", + "32792": "AB890X", + "32793": "AB890X", + "32794": "AB890X", + "32795": "AB890X", + "32796": "AB890X", + "32798": "AB890X", + "32799": "AB890X", + "32801": "AB890X", + "32802": "AB890X", + "32803": "AB890X", + "32804": "AB890X", + "32805": "AB890X", + "32806": "AB890X", + "32807": "AB890X", + "32808": "AB890X", + "32809": "AB890X", + "32810": "AB890X", + "32811": "AB890X", + "32812": "AB890X", + "32814": "AB890X", + "32815": "AB890X", + "32816": "AB890X", + "32817": "AB890X", + "32818": "AB890X", + "32819": "AB890X", + "32820": "AB890X", + "32821": "AB890X", + "32822": "AB890X", + "32824": "AB890X", + "32825": "AB890X", + "32826": "AB890X", + "32827": "AB890X", + "32828": "AB890X", + "32829": "AB890X", + "32830": "AB890X", + "32831": "AB890X", + "32832": "AB890X", + "32833": "AB890X", + "32834": "AB890X", + "32835": "AB890X", + "32836": "AB890X", + "32837": "AB890X", + "32839": "AB890X", + "32853": "AB890X", + "32854": "AB890X", + "32855": "AB890X", + "32856": "AB890X", + "32857": "AB890X", + "32858": "AB890X", + "32859": "AB890X", + "32860": "AB890X", + "32861": "AB890X", + "32862": "AB890X", + "32867": "AB890X", + "32868": "AB890X", + "32869": "AB890X", + "32872": "AB890X", + "32877": "AB890X", + "32878": "AB890X", + "32885": "AB890X", + "32886": "AB890X", + "32887": "AB890X", + "32890": "AB890X", + "32891": "AB890X", + "32893": "AB890X", + "32896": "AB890X", + "32897": "AB890X", + "32898": "AB890X", + "32899": "AB890X", + "32901": "AB890X", + "32902": "AB890X", + "32903": "AB890X", + "32904": "AB890X", + "32905": "AB890X", + "32906": "AB890X", + "32907": "AB890X", + "32908": "AB890X", + "32909": "AB890X", + "32910": "AB890X", + "32911": "AB890X", + "32912": "AB890X", + "32919": "AB890X", + "32920": "AB890X", + "32922": "AB890X", + "32923": "AB890X", + "32924": "AB890X", + "32925": "AB890X", + "32926": "AB890X", + "32927": "AB890X", + "32931": "AB890X", + "32932": "AB890X", + "32934": "AB890X", + "32935": "AB890X", + "32936": "AB890X", + "32937": "AB890X", + "32940": "AB890X", + "32941": "AB890X", + "32948": "AB892X", + "32949": "AB890X", + "32950": "AB890X", + "32951": "AB890X", + "32952": "AB890X", + "32953": "AB890X", + "32954": "AB890X", + "32955": "AB890X", + "32956": "AB890X", + "32957": "AB892X", + "32958": "AB892X", + "32959": "AB890X", + "32960": "AB892X", + "32961": "AB892X", + "32962": "AB892X", + "32963": "AB892X", + "32964": "AB892X", + "32965": "AB892X", + "32966": "AB892X", + "32967": "AB892X", + "32968": "AB892X", + "32969": "AB892X", + "32970": "AB892X", + "32971": "AB892X", + "32976": "AB892X", + "32978": "AB892X", + "33001": "AB889X", + "33002": "AB889X", + "33004": "AB889X", + "33008": "AB889X", + "33009": "AB889X", + "33010": "AB889X", + "33011": "AB889X", + "33012": "AB889X", + "33013": "AB889X", + "33014": "AB889X", + "33015": "AB889X", + "33016": "AB889X", + "33017": "AB889X", + "33018": "AB889X", + "33019": "AB889X", + "33020": "AB889X", + "33021": "AB889X", + "33022": "AB889X", + "33023": "AB889X", + "33024": "AB889X", + "33025": "AB889X", + "33026": "AB889X", + "33027": "AB889X", + "33028": "AB889X", + "33029": "AB889X", + "33030": "AB889X", + "33031": "AB889X", + "33032": "AB889X", + "33033": "AB889X", + "33034": "AB889X", + "33035": "AB889X", + "33036": "AB889X", + "33037": "AB889X", + "33039": "AB889X", + "33040": "AB889X", + "33041": "AB889X", + "33042": "AB889X", + "33043": "AB889X", + "33045": "AB889X", + "33050": "AB889X", + "33051": "AB889X", + "33052": "AB889X", + "33054": "AB889X", + "33055": "AB889X", + "33056": "AB889X", + "33060": "AB889X", + "33061": "AB889X", + "33062": "AB889X", + "33063": "AB889X", + "33064": "AB889X", + "33065": "AB889X", + "33066": "AB889X", + "33067": "AB889X", + "33068": "AB889X", + "33069": "AB889X", + "33070": "AB889X", + "33071": "AB889X", + "33072": "AB889X", + "33073": "AB889X", + "33074": "AB889X", + "33075": "AB889X", + "33076": "AB889X", + "33077": "AB889X", + "33081": "AB889X", + "33082": "AB889X", + "33083": "AB889X", + "33084": "AB889X", + "33090": "AB889X", + "33092": "AB889X", + "33093": "AB889X", + "33097": "AB889X", + "33101": "AB889X", + "33102": "AB889X", + "33107": "AB889X", + "33109": "AB889X", + "33110": "AB889X", + "33111": "AB889X", + "33112": "AB889X", + "33114": "AB889X", + "33116": "AB889X", + "33119": "AB889X", + "33121": "AB889X", + "33122": "AB889X", + "33124": "AB889X", + "33125": "AB889X", + "33126": "AB889X", + "33127": "AB889X", + "33128": "AB889X", + "33129": "AB889X", + "33130": "AB889X", + "33131": "AB889X", + "33132": "AB889X", + "33133": "AB889X", + "33134": "AB889X", + "33135": "AB889X", + "33136": "AB889X", + "33137": "AB889X", + "33138": "AB889X", + "33139": "AB889X", + "33140": "AB889X", + "33141": "AB889X", + "33142": "AB889X", + "33143": "AB889X", + "33144": "AB889X", + "33145": "AB889X", + "33146": "AB889X", + "33147": "AB889X", + "33148": "AB889X", + "33149": "AB889X", + "33150": "AB889X", + "33151": "AB889X", + "33152": "AB889X", + "33153": "AB889X", + "33154": "AB889X", + "33155": "AB889X", + "33156": "AB889X", + "33157": "AB889X", + "33158": "AB889X", + "33159": "AB889X", + "33160": "AB889X", + "33161": "AB889X", + "33162": "AB889X", + "33163": "AB889X", + "33164": "AB889X", + "33165": "AB889X", + "33166": "AB889X", + "33167": "AB889X", + "33168": "AB889X", + "33169": "AB889X", + "33170": "AB889X", + "33172": "AB889X", + "33173": "AB889X", + "33174": "AB889X", + "33175": "AB889X", + "33176": "AB889X", + "33177": "AB889X", + "33178": "AB889X", + "33179": "AB889X", + "33180": "AB889X", + "33181": "AB889X", + "33182": "AB889X", + "33183": "AB889X", + "33184": "AB889X", + "33185": "AB889X", + "33186": "AB889X", + "33187": "AB889X", + "33188": "AB889X", + "33189": "AB889X", + "33190": "AB889X", + "33193": "AB889X", + "33194": "AB889X", + "33195": "AB889X", + "33196": "AB889X", + "33197": "AB889X", + "33199": "AB889X", + "33231": "AB889X", + "33233": "AB889X", + "33234": "AB889X", + "33238": "AB889X", + "33239": "AB889X", + "33242": "AB889X", + "33243": "AB889X", + "33245": "AB889X", + "33247": "AB889X", + "33255": "AB889X", + "33256": "AB889X", + "33257": "AB889X", + "33261": "AB889X", + "33265": "AB889X", + "33266": "AB889X", + "33269": "AB889X", + "33280": "AB889X", + "33283": "AB889X", + "33296": "AB889X", + "33299": "AB889X", + "33301": "AB889X", + "33302": "AB889X", + "33303": "AB889X", + "33304": "AB889X", + "33305": "AB889X", + "33306": "AB889X", + "33307": "AB889X", + "33308": "AB889X", + "33309": "AB889X", + "33310": "AB889X", + "33311": "AB889X", + "33312": "AB889X", + "33313": "AB889X", + "33314": "AB889X", + "33315": "AB889X", + "33316": "AB889X", + "33317": "AB889X", + "33318": "AB889X", + "33319": "AB889X", + "33320": "AB889X", + "33321": "AB889X", + "33322": "AB889X", + "33323": "AB889X", + "33324": "AB889X", + "33325": "AB889X", + "33326": "AB889X", + "33327": "AB889X", + "33328": "AB889X", + "33329": "AB889X", + "33330": "AB889X", + "33331": "AB889X", + "33332": "AB889X", + "33334": "AB889X", + "33335": "AB889X", + "33336": "AB889X", + "33337": "AB889X", + "33338": "AB889X", + "33339": "AB889X", + "33340": "AB889X", + "33345": "AB889X", + "33346": "AB889X", + "33348": "AB889X", + "33349": "AB889X", + "33351": "AB889X", + "33355": "AB889X", + "33359": "AB889X", + "33388": "AB889X", + "33394": "AB889X", + "33400": "AB890X", + "33401": "AB892X", + "33402": "AB892X", + "33403": "AB892X", + "33404": "AB892X", + "33405": "AB892X", + "33406": "AB892X", + "33407": "AB892X", + "33408": "AB892X", + "33409": "AB892X", + "33410": "AB892X", + "33411": "AB892X", + "33412": "AB892X", + "33413": "AB892X", + "33414": "AB892X", + "33415": "AB892X", + "33416": "AB892X", + "33417": "AB892X", + "33418": "AB892X", + "33419": "AB892X", + "33420": "AB892X", + "33421": "AB892X", + "33422": "AB892X", + "33424": "AB892X", + "33425": "AB892X", + "33426": "AB892X", + "33427": "AB892X", + "33428": "AB892X", + "33429": "AB892X", + "33430": "AB892X", + "33431": "AB892X", + "33432": "AB892X", + "33433": "AB892X", + "33434": "AB892X", + "33435": "AB892X", + "33436": "AB892X", + "33437": "AB892X", + "33438": "AB892X", + "33439": "AB892X", + "33440": "AB892X", + "33441": "AB889X", + "33442": "AB889X", + "33443": "AB889X", + "33444": "AB892X", + "33445": "AB892X", + "33446": "AB892X", + "33447": "AB892X", + "33448": "AB892X", + "33449": "AB892X", + "33454": "AB892X", + "33455": "AB892X", + "33458": "AB892X", + "33459": "AB892X", + "33460": "AB892X", + "33461": "AB892X", + "33462": "AB892X", + "33463": "AB892X", + "33464": "AB892X", + "33465": "AB892X", + "33466": "AB892X", + "33467": "AB892X", + "33468": "AB892X", + "33469": "AB892X", + "33470": "AB892X", + "33471": "AB892X", + "33474": "AB892X", + "33475": "AB892X", + "33476": "AB892X", + "33477": "AB892X", + "33478": "AB892X", + "33480": "AB892X", + "33481": "AB892X", + "33482": "AB892X", + "33483": "AB892X", + "33484": "AB892X", + "33486": "AB892X", + "33487": "AB892X", + "33488": "AB892X", + "33493": "AB892X", + "33496": "AB892X", + "33497": "AB892X", + "33498": "AB892X", + "33499": "AB892X", + "33500": "AB890X", + "33503": "AB892X", + "33508": "AB892X", + "33509": "AB892X", + "33510": "AB892X", + "33511": "AB892X", + "33513": "AB890X", + "33514": "AB890X", + "33521": "AB890X", + "33523": "AB892X", + "33524": "AB892X", + "33525": "AB892X", + "33526": "AB892X", + "33527": "AB892X", + "33530": "AB892X", + "33534": "AB892X", + "33537": "AB892X", + "33538": "AB890X", + "33539": "AB892X", + "33540": "AB892X", + "33541": "AB892X", + "33542": "AB892X", + "33543": "AB892X", + "33544": "AB892X", + "33545": "AB892X", + "33547": "AB892X", + "33548": "AB892X", + "33549": "AB892X", + "33550": "AB892X", + "33556": "AB892X", + "33558": "AB892X", + "33559": "AB892X", + "33563": "AB892X", + "33564": "AB892X", + "33565": "AB892X", + "33566": "AB892X", + "33567": "AB892X", + "33568": "AB892X", + "33569": "AB892X", + "33570": "AB892X", + "33571": "AB892X", + "33572": "AB892X", + "33573": "AB892X", + "33574": "AB892X", + "33575": "AB892X", + "33576": "AB892X", + "33578": "AB892X", + "33579": "AB892X", + "33583": "AB892X", + "33584": "AB892X", + "33585": "AB890X", + "33586": "AB892X", + "33587": "AB892X", + "33592": "AB892X", + "33593": "AB892X", + "33594": "AB892X", + "33595": "AB892X", + "33596": "AB892X", + "33597": "AB890X", + "33598": "AB892X", + "33601": "AB892X", + "33602": "AB892X", + "33603": "AB892X", + "33604": "AB892X", + "33605": "AB892X", + "33606": "AB892X", + "33607": "AB892X", + "33608": "AB892X", + "33609": "AB892X", + "33610": "AB892X", + "33611": "AB892X", + "33612": "AB892X", + "33613": "AB892X", + "33614": "AB892X", + "33615": "AB892X", + "33616": "AB892X", + "33617": "AB892X", + "33618": "AB892X", + "33619": "AB892X", + "33620": "AB892X", + "33621": "AB892X", + "33622": "AB892X", + "33623": "AB892X", + "33624": "AB892X", + "33625": "AB892X", + "33626": "AB892X", + "33629": "AB892X", + "33630": "AB889X", + "33631": "AB892X", + "33633": "AB892X", + "33634": "AB892X", + "33635": "AB892X", + "33637": "AB892X", + "33647": "AB892X", + "33650": "AB892X", + "33651": "AB892X", + "33655": "AB892X", + "33660": "AB892X", + "33661": "AB892X", + "33662": "AB892X", + "33663": "AB892X", + "33664": "AB892X", + "33672": "AB892X", + "33673": "AB892X", + "33674": "AB892X", + "33675": "AB892X", + "33677": "AB892X", + "33679": "AB892X", + "33680": "AB892X", + "33681": "AB892X", + "33682": "AB892X", + "33684": "AB892X", + "33685": "AB892X", + "33686": "AB892X", + "33687": "AB892X", + "33688": "AB892X", + "33689": "AB892X", + "33690": "AB892X", + "33694": "AB892X", + "33697": "AB892X", + "33701": "AB892X", + "33702": "AB892X", + "33703": "AB892X", + "33704": "AB892X", + "33705": "AB892X", + "33706": "AB892X", + "33707": "AB892X", + "33708": "AB892X", + "33709": "AB892X", + "33710": "AB892X", + "33711": "AB892X", + "33712": "AB892X", + "33713": "AB892X", + "33714": "AB892X", + "33715": "AB892X", + "33716": "AB892X", + "33729": "AB892X", + "33730": "AB892X", + "33731": "AB892X", + "33732": "AB892X", + "33733": "AB892X", + "33734": "AB892X", + "33736": "AB892X", + "33737": "AB892X", + "33738": "AB892X", + "33740": "AB892X", + "33741": "AB892X", + "33742": "AB892X", + "33743": "AB892X", + "33744": "AB892X", + "33747": "AB892X", + "33755": "AB892X", + "33756": "AB892X", + "33757": "AB892X", + "33758": "AB892X", + "33759": "AB892X", + "33760": "AB892X", + "33761": "AB892X", + "33762": "AB892X", + "33763": "AB892X", + "33764": "AB892X", + "33765": "AB892X", + "33766": "AB892X", + "33767": "AB892X", + "33769": "AB892X", + "33770": "AB892X", + "33771": "AB892X", + "33772": "AB892X", + "33773": "AB892X", + "33774": "AB892X", + "33775": "AB892X", + "33776": "AB892X", + "33777": "AB892X", + "33778": "AB892X", + "33779": "AB892X", + "33780": "AB892X", + "33781": "AB892X", + "33782": "AB892X", + "33784": "AB892X", + "33785": "AB892X", + "33786": "AB892X", + "33801": "AB892X", + "33802": "AB892X", + "33803": "AB892X", + "33804": "AB892X", + "33805": "AB892X", + "33806": "AB892X", + "33807": "AB892X", + "33809": "AB892X", + "33810": "AB892X", + "33811": "AB892X", + "33812": "AB892X", + "33813": "AB892X", + "33815": "AB892X", + "33820": "AB892X", + "33823": "AB892X", + "33825": "AB892X", + "33826": "AB892X", + "33827": "AB892X", + "33830": "AB892X", + "33831": "AB892X", + "33834": "AB892X", + "33835": "AB892X", + "33836": "AB892X", + "33837": "AB892X", + "33838": "AB892X", + "33839": "AB892X", + "33840": "AB890X", + "33841": "AB892X", + "33843": "AB892X", + "33844": "AB892X", + "33845": "AB892X", + "33846": "AB892X", + "33847": "AB892X", + "33848": "AB890X", + "33849": "AB892X", + "33850": "AB892X", + "33851": "AB892X", + "33852": "AB892X", + "33853": "AB892X", + "33854": "AB892X", + "33855": "AB892X", + "33856": "AB892X", + "33857": "AB892X", + "33858": "AB892X", + "33859": "AB892X", + "33860": "AB892X", + "33862": "AB892X", + "33863": "AB892X", + "33865": "AB892X", + "33867": "AB892X", + "33868": "AB892X", + "33870": "AB892X", + "33871": "AB892X", + "33872": "AB892X", + "33873": "AB892X", + "33875": "AB892X", + "33876": "AB892X", + "33877": "AB892X", + "33880": "AB892X", + "33881": "AB892X", + "33882": "AB892X", + "33883": "AB892X", + "33884": "AB892X", + "33885": "AB892X", + "33888": "AB892X", + "33890": "AB892X", + "33896": "AB892X", + "33897": "AB890X", + "33898": "AB892X", + "33901": "AB892X", + "33902": "AB892X", + "33903": "AB892X", + "33904": "AB892X", + "33905": "AB892X", + "33906": "AB892X", + "33907": "AB892X", + "33908": "AB892X", + "33909": "AB892X", + "33910": "AB892X", + "33911": "AB892X", + "33912": "AB892X", + "33913": "AB892X", + "33914": "AB892X", + "33915": "AB892X", + "33916": "AB892X", + "33917": "AB892X", + "33918": "AB892X", + "33919": "AB892X", + "33920": "AB892X", + "33921": "AB892X", + "33922": "AB892X", + "33924": "AB892X", + "33927": "AB892X", + "33928": "AB892X", + "33930": "AB892X", + "33931": "AB892X", + "33932": "AB892X", + "33935": "AB892X", + "33936": "AB892X", + "33938": "AB892X", + "33944": "AB892X", + "33945": "AB892X", + "33946": "AB892X", + "33947": "AB892X", + "33948": "AB892X", + "33949": "AB892X", + "33950": "AB892X", + "33951": "AB892X", + "33952": "AB892X", + "33953": "AB892X", + "33954": "AB892X", + "33955": "AB892X", + "33956": "AB892X", + "33957": "AB892X", + "33960": "AB892X", + "33965": "AB892X", + "33966": "AB892X", + "33967": "AB892X", + "33970": "AB892X", + "33971": "AB892X", + "33972": "AB892X", + "33973": "AB892X", + "33974": "AB892X", + "33975": "AB892X", + "33976": "AB892X", + "33980": "AB892X", + "33981": "AB892X", + "33982": "AB892X", + "33983": "AB892X", + "33990": "AB892X", + "33991": "AB892X", + "33993": "AB892X", + "33994": "AB892X", + "34029": "AB891X", + "34101": "AB892X", + "34102": "AB892X", + "34103": "AB892X", + "34104": "AB892X", + "34105": "AB892X", + "34106": "AB892X", + "34107": "AB892X", + "34108": "AB892X", + "34109": "AB892X", + "34110": "AB892X", + "34112": "AB892X", + "34113": "AB892X", + "34114": "AB892X", + "34116": "AB892X", + "34117": "AB892X", + "34119": "AB892X", + "34120": "AB892X", + "34133": "AB892X", + "34134": "AB892X", + "34135": "AB892X", + "34136": "AB892X", + "34137": "AB892X", + "34138": "AB892X", + "34139": "AB892X", + "34140": "AB892X", + "34141": "AB889X", + "34142": "AB892X", + "34143": "AB892X", + "34145": "AB889X", + "34146": "AB892X", + "34201": "AB892X", + "34202": "AB892X", + "34203": "AB892X", + "34204": "AB892X", + "34205": "AB892X", + "34206": "AB892X", + "34207": "AB892X", + "34208": "AB892X", + "34209": "AB892X", + "34210": "AB892X", + "34211": "AB892X", + "34212": "AB892X", + "34215": "AB892X", + "34216": "AB892X", + "34217": "AB892X", + "34218": "AB892X", + "34219": "AB892X", + "34220": "AB892X", + "34221": "AB892X", + "34222": "AB892X", + "34223": "AB892X", + "34224": "AB892X", + "34228": "AB892X", + "34229": "AB892X", + "34230": "AB892X", + "34231": "AB892X", + "34232": "AB892X", + "34233": "AB892X", + "34234": "AB892X", + "34235": "AB892X", + "34236": "AB892X", + "34237": "AB892X", + "34238": "AB892X", + "34239": "AB892X", + "34240": "AB892X", + "34241": "AB892X", + "34242": "AB892X", + "34243": "AB892X", + "34250": "AB892X", + "34251": "AB892X", + "34260": "AB892X", + "34264": "AB892X", + "34265": "AB892X", + "34266": "AB892X", + "34267": "AB892X", + "34268": "AB892X", + "34269": "AB892X", + "34270": "AB892X", + "34272": "AB892X", + "34274": "AB892X", + "34275": "AB892X", + "34276": "AB892X", + "34277": "AB892X", + "34278": "AB892X", + "34280": "AB892X", + "34281": "AB892X", + "34282": "AB892X", + "34284": "AB892X", + "34285": "AB892X", + "34286": "AB892X", + "34287": "AB892X", + "34288": "AB892X", + "34289": "AB892X", + "34292": "AB892X", + "34293": "AB892X", + "34295": "AB892X", + "34420": "AB890X", + "34421": "AB890X", + "34423": "AB892X", + "34428": "AB892X", + "34429": "AB892X", + "34430": "AB890X", + "34431": "AB890X", + "34432": "AB890X", + "34433": "AB892X", + "34434": "AB892X", + "34436": "AB892X", + "34442": "AB892X", + "34445": "AB892X", + "34446": "AB892X", + "34447": "AB892X", + "34448": "AB892X", + "34449": "AB888X", + "34450": "AB892X", + "34451": "AB892X", + "34452": "AB892X", + "34453": "AB892X", + "34460": "AB892X", + "34461": "AB892X", + "34464": "AB892X", + "34465": "AB892X", + "34470": "AB890X", + "34471": "AB890X", + "34472": "AB890X", + "34473": "AB890X", + "34474": "AB890X", + "34475": "AB890X", + "34476": "AB890X", + "34477": "AB890X", + "34478": "AB890X", + "34479": "AB890X", + "34480": "AB890X", + "34481": "AB890X", + "34482": "AB890X", + "34483": "AB890X", + "34484": "AB890X", + "34487": "AB892X", + "34488": "AB890X", + "34489": "AB890X", + "34491": "AB890X", + "34492": "AB890X", + "34498": "AB888X", + "34601": "AB892X", + "34602": "AB892X", + "34603": "AB892X", + "34604": "AB892X", + "34605": "AB892X", + "34606": "AB892X", + "34607": "AB892X", + "34608": "AB892X", + "34609": "AB892X", + "34610": "AB892X", + "34611": "AB892X", + "34613": "AB892X", + "34614": "AB892X", + "34636": "AB892X", + "34637": "AB892X", + "34638": "AB892X", + "34639": "AB892X", + "34652": "AB892X", + "34653": "AB892X", + "34654": "AB892X", + "34655": "AB892X", + "34656": "AB892X", + "34660": "AB892X", + "34661": "AB892X", + "34667": "AB892X", + "34668": "AB892X", + "34669": "AB892X", + "34673": "AB892X", + "34674": "AB892X", + "34677": "AB892X", + "34679": "AB892X", + "34680": "AB892X", + "34681": "AB892X", + "34682": "AB892X", + "34683": "AB892X", + "34684": "AB892X", + "34685": "AB892X", + "34688": "AB892X", + "34689": "AB892X", + "34690": "AB892X", + "34691": "AB892X", + "34692": "AB892X", + "34695": "AB892X", + "34697": "AB892X", + "34698": "AB892X", + "34700": "AB890X", + "34705": "AB890X", + "34711": "AB890X", + "34712": "AB890X", + "34713": "AB890X", + "34714": "AB890X", + "34715": "AB890X", + "34729": "AB890X", + "34731": "AB890X", + "34734": "AB890X", + "34736": "AB890X", + "34737": "AB890X", + "34739": "AB890X", + "34740": "AB890X", + "34741": "AB890X", + "34742": "AB890X", + "34743": "AB890X", + "34744": "AB890X", + "34745": "AB890X", + "34746": "AB890X", + "34747": "AB890X", + "34748": "AB890X", + "34749": "AB890X", + "34753": "AB890X", + "34755": "AB890X", + "34756": "AB890X", + "34758": "AB890X", + "34759": "AB890X", + "34760": "AB890X", + "34761": "AB890X", + "34762": "AB890X", + "34769": "AB890X", + "34770": "AB890X", + "34771": "AB890X", + "34772": "AB890X", + "34773": "AB890X", + "34777": "AB890X", + "34778": "AB890X", + "34785": "AB890X", + "34786": "AB890X", + "34787": "AB890X", + "34788": "AB890X", + "34789": "AB890X", + "34797": "AB890X", + "34945": "AB892X", + "34946": "AB892X", + "34947": "AB892X", + "34948": "AB892X", + "34949": "AB889X", + "34950": "AB892X", + "34951": "AB892X", + "34952": "AB892X", + "34953": "AB892X", + "34954": "AB892X", + "34956": "AB892X", + "34957": "AB892X", + "34958": "AB892X", + "34972": "AB892X", + "34973": "AB892X", + "34974": "AB892X", + "34979": "AB892X", + "34981": "AB892X", + "34982": "AB892X", + "34983": "AB892X", + "34984": "AB892X", + "34985": "AB892X", + "34986": "AB892X", + "34987": "AB892X", + "34988": "AB892X", + "34990": "AB892X", + "34991": "AB892X", + "34992": "AB892X", + "34994": "AB892X", + "34995": "AB892X", + "34996": "AB892X", + "34997": "AB892X", + "35004": "AB887X", + "35005": "AB887X", + "35006": "AB887X", + "35007": "AB887X", + "35010": "AB890X", + "35011": "AB890X", + "35013": "AB887X", + "35014": "AB887X", + "35015": "AB887X", + "35016": "AB887X", + "35019": "AB887X", + "35020": "AB887X", + "35021": "AB887X", + "35022": "AB887X", + "35023": "AB887X", + "35031": "AB887X", + "35032": "AB887X", + "35033": "AB887X", + "35034": "AB887X", + "35035": "AB887X", + "35036": "AB887X", + "35038": "AB887X", + "35040": "AB887X", + "35041": "AB887X", + "35042": "AB887X", + "35043": "AB887X", + "35044": "AB887X", + "35045": "AB887X", + "35046": "AB887X", + "35048": "AB887X", + "35049": "AB887X", + "35051": "AB887X", + "35052": "AB887X", + "35053": "AB887X", + "35054": "AB887X", + "35055": "AB887X", + "35056": "AB887X", + "35057": "AB887X", + "35058": "AB887X", + "35060": "AB887X", + "35061": "AB887X", + "35062": "AB887X", + "35063": "AB887X", + "35064": "AB887X", + "35068": "AB887X", + "35070": "AB887X", + "35071": "AB887X", + "35072": "AB890X", + "35073": "AB887X", + "35074": "AB887X", + "35077": "AB887X", + "35078": "AB887X", + "35079": "AB887X", + "35080": "AB887X", + "35082": "AB889X", + "35083": "AB887X", + "35085": "AB887X", + "35087": "AB887X", + "35089": "AB890X", + "35091": "AB887X", + "35094": "AB887X", + "35096": "AB887X", + "35097": "AB887X", + "35098": "AB887X", + "35111": "AB887X", + "35112": "AB887X", + "35114": "AB887X", + "35115": "AB887X", + "35116": "AB887X", + "35117": "AB887X", + "35118": "AB887X", + "35119": "AB887X", + "35120": "AB887X", + "35121": "AB887X", + "35123": "AB887X", + "35124": "AB887X", + "35125": "AB887X", + "35126": "AB887X", + "35127": "AB887X", + "35128": "AB887X", + "35130": "AB887X", + "35131": "AB887X", + "35133": "AB887X", + "35135": "AB887X", + "35136": "AB890X", + "35137": "AB887X", + "35139": "AB887X", + "35142": "AB887X", + "35143": "AB887X", + "35144": "AB887X", + "35146": "AB887X", + "35147": "AB887X", + "35148": "AB887X", + "35149": "AB887X", + "35150": "AB887X", + "35151": "AB887X", + "35160": "AB887X", + "35161": "AB887X", + "35171": "AB887X", + "35172": "AB887X", + "35173": "AB887X", + "35175": "AB887X", + "35176": "AB887X", + "35178": "AB887X", + "35179": "AB887X", + "35180": "AB887X", + "35181": "AB887X", + "35182": "AB887X", + "35183": "AB890X", + "35184": "AB887X", + "35185": "AB887X", + "35186": "AB887X", + "35187": "AB887X", + "35188": "AB887X", + "35201": "AB887X", + "35202": "AB887X", + "35203": "AB887X", + "35204": "AB887X", + "35205": "AB887X", + "35206": "AB887X", + "35207": "AB887X", + "35208": "AB887X", + "35209": "AB887X", + "35210": "AB887X", + "35211": "AB887X", + "35212": "AB887X", + "35213": "AB887X", + "35214": "AB887X", + "35215": "AB887X", + "35216": "AB887X", + "35217": "AB887X", + "35218": "AB887X", + "35219": "AB887X", + "35220": "AB887X", + "35221": "AB887X", + "35222": "AB887X", + "35223": "AB887X", + "35224": "AB887X", + "35225": "AB887X", + "35226": "AB887X", + "35228": "AB887X", + "35229": "AB887X", + "35230": "AB887X", + "35231": "AB887X", + "35232": "AB887X", + "35233": "AB887X", + "35234": "AB887X", + "35235": "AB887X", + "35236": "AB887X", + "35237": "AB887X", + "35238": "AB887X", + "35240": "AB887X", + "35242": "AB887X", + "35243": "AB887X", + "35244": "AB887X", + "35245": "AB887X", + "35246": "AB887X", + "35249": "AB887X", + "35253": "AB887X", + "35254": "AB887X", + "35255": "AB887X", + "35259": "AB887X", + "35260": "AB887X", + "35261": "AB887X", + "35263": "AB887X", + "35266": "AB887X", + "35277": "AB887X", + "35278": "AB887X", + "35279": "AB887X", + "35280": "AB887X", + "35281": "AB887X", + "35282": "AB887X", + "35283": "AB887X", + "35285": "AB887X", + "35286": "AB887X", + "35287": "AB887X", + "35288": "AB887X", + "35289": "AB887X", + "35290": "AB887X", + "35291": "AB887X", + "35292": "AB887X", + "35293": "AB887X", + "35294": "AB887X", + "35295": "AB887X", + "35296": "AB887X", + "35297": "AB887X", + "35298": "AB887X", + "35299": "AB887X", + "35401": "AB887X", + "35402": "AB887X", + "35403": "AB887X", + "35404": "AB887X", + "35405": "AB887X", + "35406": "AB887X", + "35407": "AB887X", + "35440": "AB887X", + "35441": "AB887X", + "35442": "AB887X", + "35443": "AB887X", + "35444": "AB887X", + "35446": "AB887X", + "35447": "AB887X", + "35448": "AB887X", + "35449": "AB887X", + "35452": "AB887X", + "35453": "AB887X", + "35456": "AB887X", + "35457": "AB887X", + "35458": "AB887X", + "35459": "AB887X", + "35460": "AB887X", + "35461": "AB887X", + "35462": "AB887X", + "35463": "AB887X", + "35464": "AB887X", + "35466": "AB887X", + "35468": "AB887X", + "35469": "AB887X", + "35470": "AB887X", + "35471": "AB887X", + "35473": "AB887X", + "35474": "AB887X", + "35475": "AB887X", + "35476": "AB887X", + "35477": "AB887X", + "35478": "AB887X", + "35480": "AB887X", + "35481": "AB887X", + "35482": "AB887X", + "35485": "AB887X", + "35486": "AB887X", + "35487": "AB887X", + "35490": "AB887X", + "35491": "AB887X", + "35501": "AB887X", + "35502": "AB887X", + "35503": "AB887X", + "35504": "AB887X", + "35540": "AB887X", + "35541": "AB887X", + "35542": "AB887X", + "35543": "AB887X", + "35544": "AB887X", + "35545": "AB887X", + "35546": "AB887X", + "35548": "AB887X", + "35549": "AB887X", + "35550": "AB887X", + "35551": "AB887X", + "35552": "AB887X", + "35553": "AB887X", + "35554": "AB887X", + "35555": "AB887X", + "35559": "AB887X", + "35560": "AB887X", + "35563": "AB887X", + "35564": "AB887X", + "35565": "AB887X", + "35570": "AB887X", + "35571": "AB887X", + "35572": "AB887X", + "35573": "AB887X", + "35574": "AB887X", + "35575": "AB887X", + "35576": "AB887X", + "35577": "AB887X", + "35578": "AB887X", + "35579": "AB887X", + "35580": "AB887X", + "35581": "AB887X", + "35582": "AB887X", + "35584": "AB887X", + "35585": "AB887X", + "35586": "AB887X", + "35587": "AB887X", + "35592": "AB887X", + "35593": "AB887X", + "35594": "AB887X", + "35601": "AB887X", + "35602": "AB887X", + "35603": "AB887X", + "35609": "AB887X", + "35610": "AB887X", + "35611": "AB887X", + "35612": "AB887X", + "35613": "AB887X", + "35614": "AB887X", + "35615": "AB887X", + "35616": "AB887X", + "35617": "AB887X", + "35618": "AB887X", + "35619": "AB887X", + "35620": "AB887X", + "35621": "AB887X", + "35622": "AB887X", + "35630": "AB887X", + "35631": "AB887X", + "35632": "AB887X", + "35633": "AB887X", + "35634": "AB887X", + "35640": "AB887X", + "35643": "AB887X", + "35645": "AB887X", + "35646": "AB887X", + "35647": "AB887X", + "35648": "AB887X", + "35649": "AB887X", + "35650": "AB887X", + "35651": "AB887X", + "35652": "AB887X", + "35653": "AB887X", + "35654": "AB887X", + "35660": "AB887X", + "35661": "AB887X", + "35662": "AB887X", + "35670": "AB887X", + "35671": "AB887X", + "35672": "AB887X", + "35673": "AB887X", + "35674": "AB887X", + "35677": "AB887X", + "35699": "AB887X", + "35739": "AB887X", + "35740": "AB887X", + "35741": "AB887X", + "35742": "AB887X", + "35744": "AB887X", + "35745": "AB887X", + "35746": "AB887X", + "35747": "AB887X", + "35748": "AB887X", + "35749": "AB887X", + "35750": "AB887X", + "35751": "AB887X", + "35752": "AB887X", + "35754": "AB887X", + "35755": "AB887X", + "35756": "AB887X", + "35757": "AB887X", + "35758": "AB887X", + "35759": "AB887X", + "35760": "AB887X", + "35761": "AB887X", + "35762": "AB887X", + "35763": "AB887X", + "35764": "AB887X", + "35765": "AB887X", + "35766": "AB887X", + "35767": "AB887X", + "35768": "AB887X", + "35769": "AB887X", + "35771": "AB887X", + "35772": "AB887X", + "35773": "AB887X", + "35774": "AB887X", + "35775": "AB887X", + "35776": "AB887X", + "35801": "AB887X", + "35802": "AB887X", + "35803": "AB887X", + "35804": "AB887X", + "35805": "AB887X", + "35806": "AB887X", + "35807": "AB887X", + "35808": "AB887X", + "35809": "AB887X", + "35810": "AB887X", + "35811": "AB887X", + "35812": "AB887X", + "35813": "AB887X", + "35814": "AB887X", + "35815": "AB887X", + "35816": "AB887X", + "35824": "AB887X", + "35893": "AB887X", + "35894": "AB887X", + "35895": "AB887X", + "35896": "AB887X", + "35897": "AB887X", + "35898": "AB887X", + "35899": "AB887X", + "35901": "AB887X", + "35902": "AB887X", + "35903": "AB887X", + "35904": "AB887X", + "35905": "AB887X", + "35906": "AB887X", + "35907": "AB887X", + "35950": "AB887X", + "35951": "AB887X", + "35952": "AB887X", + "35953": "AB887X", + "35954": "AB887X", + "35956": "AB887X", + "35957": "AB887X", + "35958": "AB887X", + "35959": "AB887X", + "35960": "AB887X", + "35961": "AB887X", + "35962": "AB887X", + "35963": "AB887X", + "35964": "AB887X", + "35966": "AB887X", + "35967": "AB887X", + "35968": "AB887X", + "35971": "AB887X", + "35972": "AB887X", + "35973": "AB887X", + "35974": "AB887X", + "35975": "AB887X", + "35976": "AB887X", + "35978": "AB887X", + "35979": "AB887X", + "35980": "AB887X", + "35981": "AB887X", + "35983": "AB887X", + "35984": "AB887X", + "35986": "AB887X", + "35987": "AB887X", + "35988": "AB887X", + "35989": "AB887X", + "35990": "AB887X", + "36003": "AB890X", + "36005": "AB890X", + "36006": "AB890X", + "36008": "AB890X", + "36009": "AB890X", + "36010": "AB890X", + "36013": "AB890X", + "36015": "AB890X", + "36016": "AB890X", + "36017": "AB890X", + "36020": "AB890X", + "36022": "AB890X", + "36023": "AB890X", + "36024": "AB890X", + "36025": "AB890X", + "36026": "AB890X", + "36027": "AB890X", + "36028": "AB890X", + "36029": "AB890X", + "36030": "AB890X", + "36031": "AB890X", + "36032": "AB890X", + "36033": "AB890X", + "36034": "AB890X", + "36035": "AB890X", + "36036": "AB890X", + "36037": "AB890X", + "36038": "AB890X", + "36039": "AB890X", + "36040": "AB890X", + "36041": "AB890X", + "36042": "AB890X", + "36043": "AB890X", + "36045": "AB890X", + "36046": "AB890X", + "36047": "AB890X", + "36048": "AB890X", + "36049": "AB890X", + "36051": "AB890X", + "36052": "AB890X", + "36053": "AB890X", + "36054": "AB890X", + "36057": "AB890X", + "36061": "AB890X", + "36062": "AB890X", + "36064": "AB890X", + "36065": "AB890X", + "36066": "AB890X", + "36067": "AB890X", + "36068": "AB890X", + "36069": "AB890X", + "36071": "AB890X", + "36072": "AB890X", + "36075": "AB890X", + "36078": "AB890X", + "36079": "AB890X", + "36080": "AB890X", + "36081": "AB890X", + "36082": "AB890X", + "36083": "AB890X", + "36087": "AB890X", + "36088": "AB890X", + "36089": "AB890X", + "36091": "AB887X", + "36092": "AB890X", + "36093": "AB890X", + "36101": "AB890X", + "36102": "AB890X", + "36103": "AB890X", + "36104": "AB890X", + "36105": "AB890X", + "36106": "AB890X", + "36107": "AB890X", + "36108": "AB890X", + "36109": "AB890X", + "36110": "AB890X", + "36111": "AB890X", + "36112": "AB890X", + "36113": "AB890X", + "36114": "AB890X", + "36115": "AB890X", + "36116": "AB890X", + "36117": "AB890X", + "36118": "AB890X", + "36119": "AB890X", + "36120": "AB890X", + "36121": "AB890X", + "36123": "AB890X", + "36124": "AB890X", + "36125": "AB890X", + "36130": "AB890X", + "36131": "AB890X", + "36132": "AB890X", + "36133": "AB890X", + "36134": "AB890X", + "36135": "AB890X", + "36140": "AB890X", + "36141": "AB890X", + "36142": "AB890X", + "36177": "AB890X", + "36191": "AB890X", + "36201": "AB887X", + "36202": "AB887X", + "36203": "AB887X", + "36204": "AB887X", + "36205": "AB887X", + "36206": "AB887X", + "36207": "AB887X", + "36210": "AB887X", + "36250": "AB887X", + "36251": "AB889X", + "36253": "AB887X", + "36254": "AB887X", + "36255": "AB889X", + "36256": "AB890X", + "36257": "AB887X", + "36258": "AB889X", + "36260": "AB887X", + "36261": "AB887X", + "36262": "AB887X", + "36263": "AB889X", + "36264": "AB887X", + "36265": "AB887X", + "36266": "AB889X", + "36267": "AB889X", + "36268": "AB887X", + "36269": "AB887X", + "36271": "AB887X", + "36272": "AB887X", + "36273": "AB887X", + "36274": "AB889X", + "36275": "AB887X", + "36276": "AB889X", + "36277": "AB887X", + "36278": "AB889X", + "36279": "AB887X", + "36280": "AB889X", + "36301": "AB890X", + "36302": "AB890X", + "36303": "AB890X", + "36304": "AB890X", + "36305": "AB890X", + "36310": "AB890X", + "36311": "AB890X", + "36312": "AB890X", + "36313": "AB890X", + "36314": "AB890X", + "36316": "AB890X", + "36317": "AB890X", + "36318": "AB890X", + "36319": "AB890X", + "36320": "AB890X", + "36321": "AB890X", + "36322": "AB890X", + "36323": "AB890X", + "36330": "AB890X", + "36331": "AB890X", + "36340": "AB890X", + "36343": "AB890X", + "36344": "AB890X", + "36345": "AB890X", + "36346": "AB890X", + "36349": "AB890X", + "36350": "AB890X", + "36351": "AB890X", + "36352": "AB890X", + "36353": "AB890X", + "36360": "AB890X", + "36361": "AB890X", + "36362": "AB890X", + "36370": "AB890X", + "36371": "AB890X", + "36373": "AB890X", + "36374": "AB890X", + "36375": "AB890X", + "36376": "AB890X", + "36401": "AB889X", + "36420": "AB890X", + "36421": "AB890X", + "36425": "AB889X", + "36426": "AB889X", + "36427": "AB889X", + "36429": "AB889X", + "36432": "AB889X", + "36435": "AB890X", + "36436": "AB889X", + "36439": "AB889X", + "36441": "AB889X", + "36442": "AB890X", + "36444": "AB889X", + "36445": "AB889X", + "36446": "AB889X", + "36449": "AB889X", + "36451": "AB889X", + "36453": "AB890X", + "36454": "AB889X", + "36455": "AB890X", + "36456": "AB890X", + "36457": "AB889X", + "36458": "AB889X", + "36460": "AB889X", + "36461": "AB889X", + "36462": "AB889X", + "36467": "AB890X", + "36470": "AB889X", + "36471": "AB889X", + "36473": "AB889X", + "36474": "AB890X", + "36475": "AB889X", + "36476": "AB890X", + "36477": "AB890X", + "36480": "AB889X", + "36481": "AB889X", + "36482": "AB889X", + "36483": "AB890X", + "36501": "AB889X", + "36502": "AB889X", + "36503": "AB889X", + "36504": "AB889X", + "36505": "AB889X", + "36507": "AB889X", + "36509": "AB889X", + "36511": "AB889X", + "36512": "AB889X", + "36513": "AB889X", + "36515": "AB889X", + "36518": "AB889X", + "36521": "AB889X", + "36522": "AB889X", + "36523": "AB889X", + "36524": "AB889X", + "36525": "AB889X", + "36526": "AB889X", + "36527": "AB889X", + "36528": "AB889X", + "36529": "AB889X", + "36530": "AB889X", + "36532": "AB889X", + "36533": "AB889X", + "36535": "AB889X", + "36536": "AB889X", + "36538": "AB889X", + "36539": "AB889X", + "36540": "AB889X", + "36541": "AB889X", + "36542": "AB889X", + "36543": "AB889X", + "36544": "AB889X", + "36545": "AB889X", + "36547": "AB889X", + "36548": "AB889X", + "36549": "AB889X", + "36550": "AB889X", + "36551": "AB889X", + "36553": "AB889X", + "36555": "AB889X", + "36556": "AB889X", + "36558": "AB889X", + "36559": "AB889X", + "36560": "AB889X", + "36561": "AB889X", + "36562": "AB889X", + "36564": "AB889X", + "36567": "AB889X", + "36568": "AB889X", + "36569": "AB889X", + "36571": "AB889X", + "36572": "AB889X", + "36574": "AB889X", + "36575": "AB889X", + "36576": "AB889X", + "36577": "AB889X", + "36578": "AB889X", + "36579": "AB889X", + "36580": "AB889X", + "36581": "AB889X", + "36582": "AB889X", + "36583": "AB889X", + "36584": "AB889X", + "36585": "AB889X", + "36587": "AB889X", + "36590": "AB889X", + "36601": "AB889X", + "36602": "AB889X", + "36603": "AB889X", + "36604": "AB889X", + "36605": "AB889X", + "36606": "AB889X", + "36607": "AB889X", + "36608": "AB889X", + "36609": "AB889X", + "36610": "AB889X", + "36611": "AB889X", + "36612": "AB889X", + "36613": "AB889X", + "36615": "AB889X", + "36616": "AB889X", + "36617": "AB889X", + "36618": "AB889X", + "36619": "AB889X", + "36621": "AB889X", + "36622": "AB889X", + "36625": "AB889X", + "36628": "AB889X", + "36630": "AB889X", + "36633": "AB889X", + "36640": "AB889X", + "36641": "AB889X", + "36644": "AB889X", + "36652": "AB889X", + "36660": "AB889X", + "36663": "AB889X", + "36670": "AB889X", + "36671": "AB889X", + "36675": "AB889X", + "36685": "AB889X", + "36688": "AB889X", + "36689": "AB889X", + "36690": "AB889X", + "36691": "AB889X", + "36693": "AB889X", + "36695": "AB889X", + "36701": "AB890X", + "36702": "AB890X", + "36703": "AB890X", + "36720": "AB890X", + "36721": "AB890X", + "36722": "AB890X", + "36723": "AB890X", + "36726": "AB890X", + "36727": "AB889X", + "36728": "AB890X", + "36732": "AB890X", + "36736": "AB890X", + "36738": "AB890X", + "36740": "AB887X", + "36741": "AB890X", + "36742": "AB890X", + "36744": "AB887X", + "36745": "AB890X", + "36748": "AB890X", + "36749": "AB890X", + "36750": "AB887X", + "36751": "AB890X", + "36752": "AB890X", + "36753": "AB890X", + "36754": "AB890X", + "36756": "AB887X", + "36758": "AB890X", + "36759": "AB890X", + "36761": "AB890X", + "36762": "AB889X", + "36763": "AB890X", + "36764": "AB890X", + "36765": "AB887X", + "36766": "AB890X", + "36767": "AB890X", + "36768": "AB890X", + "36769": "AB890X", + "36773": "AB890X", + "36775": "AB890X", + "36776": "AB887X", + "36782": "AB890X", + "36783": "AB890X", + "36784": "AB889X", + "36785": "AB890X", + "36786": "AB887X", + "36790": "AB887X", + "36792": "AB887X", + "36793": "AB887X", + "36801": "AB890X", + "36802": "AB890X", + "36803": "AB890X", + "36804": "AB890X", + "36830": "AB890X", + "36831": "AB890X", + "36832": "AB890X", + "36849": "AB890X", + "36850": "AB890X", + "36851": "AB890X", + "36852": "AB890X", + "36853": "AB890X", + "36854": "AB890X", + "36855": "AB890X", + "36856": "AB890X", + "36858": "AB890X", + "36859": "AB890X", + "36860": "AB890X", + "36861": "AB890X", + "36862": "AB890X", + "36863": "AB890X", + "36865": "AB890X", + "36866": "AB890X", + "36867": "AB890X", + "36868": "AB890X", + "36869": "AB890X", + "36870": "AB890X", + "36871": "AB890X", + "36872": "AB890X", + "36874": "AB890X", + "36875": "AB890X", + "36877": "AB890X", + "36879": "AB890X", + "36901": "AB887X", + "36904": "AB889X", + "36907": "AB887X", + "36908": "AB889X", + "36910": "AB889X", + "36912": "AB889X", + "36913": "AB889X", + "36915": "AB889X", + "36916": "AB889X", + "36919": "AB889X", + "36921": "AB889X", + "36922": "AB889X", + "36925": "AB887X", + "37010": "AB887X", + "37011": "AB887X", + "37012": "AB887X", + "37013": "AB887X", + "37014": "AB887X", + "37015": "AB887X", + "37016": "AB887X", + "37018": "AB887X", + "37019": "AB887X", + "37020": "AB887X", + "37022": "AB887X", + "37023": "AB887X", + "37024": "AB887X", + "37025": "AB887X", + "37026": "AB887X", + "37027": "AB887X", + "37028": "AB887X", + "37029": "AB887X", + "37030": "AB887X", + "37031": "AB887X", + "37032": "AB887X", + "37033": "AB887X", + "37034": "AB887X", + "37035": "AB887X", + "37036": "AB887X", + "37037": "AB887X", + "37040": "AB887X", + "37041": "AB887X", + "37042": "AB887X", + "37043": "AB887X", + "37044": "AB887X", + "37046": "AB887X", + "37047": "AB887X", + "37048": "AB887X", + "37049": "AB887X", + "37050": "AB887X", + "37051": "AB887X", + "37052": "AB887X", + "37055": "AB887X", + "37056": "AB887X", + "37057": "AB887X", + "37058": "AB887X", + "37059": "AB887X", + "37060": "AB887X", + "37061": "AB887X", + "37062": "AB887X", + "37063": "AB887X", + "37064": "AB887X", + "37065": "AB887X", + "37066": "AB887X", + "37067": "AB887X", + "37068": "AB887X", + "37069": "AB887X", + "37070": "AB887X", + "37071": "AB887X", + "37072": "AB887X", + "37073": "AB887X", + "37074": "AB887X", + "37075": "AB887X", + "37076": "AB887X", + "37077": "AB887X", + "37078": "AB887X", + "37079": "AB887X", + "37080": "AB887X", + "37082": "AB887X", + "37083": "AB887X", + "37085": "AB887X", + "37086": "AB887X", + "37087": "AB887X", + "37088": "AB887X", + "37089": "AB887X", + "37090": "AB887X", + "37091": "AB887X", + "37095": "AB887X", + "37096": "AB887X", + "37097": "AB887X", + "37098": "AB887X", + "37101": "AB887X", + "37110": "AB887X", + "37111": "AB887X", + "37115": "AB887X", + "37116": "AB887X", + "37118": "AB887X", + "37119": "AB887X", + "37121": "AB887X", + "37122": "AB887X", + "37127": "AB887X", + "37128": "AB887X", + "37129": "AB887X", + "37130": "AB887X", + "37131": "AB887X", + "37132": "AB887X", + "37133": "AB887X", + "37134": "AB887X", + "37135": "AB887X", + "37136": "AB887X", + "37137": "AB887X", + "37138": "AB887X", + "37140": "AB887X", + "37141": "AB887X", + "37142": "AB887X", + "37143": "AB887X", + "37144": "AB887X", + "37145": "AB887X", + "37146": "AB887X", + "37148": "AB887X", + "37149": "AB887X", + "37150": "AB887X", + "37151": "AB887X", + "37152": "AB887X", + "37153": "AB887X", + "37160": "AB887X", + "37161": "AB887X", + "37162": "AB887X", + "37165": "AB887X", + "37166": "AB887X", + "37167": "AB887X", + "37171": "AB887X", + "37172": "AB887X", + "37174": "AB887X", + "37175": "AB887X", + "37178": "AB887X", + "37179": "AB887X", + "37180": "AB887X", + "37181": "AB887X", + "37183": "AB887X", + "37184": "AB887X", + "37185": "AB887X", + "37186": "AB887X", + "37187": "AB887X", + "37188": "AB887X", + "37189": "AB887X", + "37190": "AB887X", + "37191": "AB887X", + "37201": "AB887X", + "37202": "AB887X", + "37203": "AB890X", + "37204": "AB887X", + "37205": "AB887X", + "37206": "AB887X", + "37207": "AB887X", + "37208": "AB887X", + "37209": "AB887X", + "37210": "AB887X", + "37211": "AB887X", + "37212": "AB887X", + "37213": "AB887X", + "37214": "AB887X", + "37215": "AB887X", + "37216": "AB887X", + "37217": "AB887X", + "37218": "AB887X", + "37219": "AB887X", + "37220": "AB887X", + "37221": "AB887X", + "37222": "AB887X", + "37224": "AB887X", + "37227": "AB887X", + "37228": "AB887X", + "37229": "AB887X", + "37230": "AB887X", + "37232": "AB887X", + "37234": "AB887X", + "37235": "AB887X", + "37236": "AB887X", + "37237": "AB887X", + "37238": "AB887X", + "37240": "AB887X", + "37241": "AB887X", + "37242": "AB887X", + "37243": "AB887X", + "37244": "AB887X", + "37245": "AB887X", + "37246": "AB887X", + "37247": "AB887X", + "37248": "AB887X", + "37249": "AB887X", + "37250": "AB887X", + "37301": "AB887X", + "37302": "AB888X", + "37303": "AB888X", + "37304": "AB888X", + "37305": "AB888X", + "37306": "AB887X", + "37307": "AB888X", + "37308": "AB888X", + "37309": "AB888X", + "37310": "AB888X", + "37311": "AB888X", + "37312": "AB888X", + "37313": "AB888X", + "37314": "AB888X", + "37315": "AB888X", + "37316": "AB888X", + "37317": "AB888X", + "37318": "AB887X", + "37320": "AB888X", + "37321": "AB888X", + "37322": "AB888X", + "37323": "AB888X", + "37324": "AB887X", + "37325": "AB888X", + "37326": "AB888X", + "37327": "AB888X", + "37328": "AB887X", + "37329": "AB888X", + "37330": "AB887X", + "37331": "AB888X", + "37332": "AB888X", + "37333": "AB888X", + "37334": "AB887X", + "37335": "AB887X", + "37336": "AB888X", + "37337": "AB888X", + "37338": "AB888X", + "37339": "AB888X", + "37340": "AB888X", + "37341": "AB888X", + "37342": "AB887X", + "37343": "AB888X", + "37345": "AB887X", + "37347": "AB888X", + "37348": "AB887X", + "37349": "AB887X", + "37350": "AB888X", + "37351": "AB888X", + "37352": "AB887X", + "37353": "AB888X", + "37354": "AB888X", + "37355": "AB887X", + "37356": "AB888X", + "37357": "AB887X", + "37359": "AB887X", + "37360": "AB887X", + "37361": "AB888X", + "37362": "AB888X", + "37363": "AB888X", + "37364": "AB888X", + "37365": "AB888X", + "37366": "AB887X", + "37367": "AB888X", + "37369": "AB888X", + "37370": "AB888X", + "37371": "AB888X", + "37372": "AB887X", + "37373": "AB888X", + "37374": "AB888X", + "37375": "AB887X", + "37376": "AB887X", + "37377": "AB888X", + "37378": "AB887X", + "37379": "AB888X", + "37380": "AB888X", + "37381": "AB888X", + "37382": "AB887X", + "37383": "AB887X", + "37384": "AB888X", + "37385": "AB888X", + "37387": "AB888X", + "37388": "AB887X", + "37389": "AB887X", + "37391": "AB888X", + "37394": "AB887X", + "37396": "AB888X", + "37397": "AB888X", + "37398": "AB887X", + "37401": "AB888X", + "37402": "AB888X", + "37403": "AB888X", + "37404": "AB888X", + "37405": "AB888X", + "37406": "AB888X", + "37407": "AB888X", + "37408": "AB888X", + "37409": "AB888X", + "37410": "AB888X", + "37411": "AB888X", + "37412": "AB888X", + "37414": "AB888X", + "37415": "AB888X", + "37416": "AB888X", + "37419": "AB888X", + "37421": "AB888X", + "37422": "AB888X", + "37424": "AB888X", + "37450": "AB888X", + "37501": "AB889X", + "37544": "AB889X", + "37601": "AB888X", + "37602": "AB888X", + "37604": "AB888X", + "37605": "AB888X", + "37614": "AB888X", + "37615": "AB888X", + "37616": "AB888X", + "37617": "AB888X", + "37618": "AB888X", + "37620": "AB888X", + "37621": "AB888X", + "37625": "AB888X", + "37640": "AB888X", + "37641": "AB888X", + "37642": "AB888X", + "37643": "AB888X", + "37644": "AB888X", + "37645": "AB888X", + "37650": "AB888X", + "37656": "AB888X", + "37657": "AB888X", + "37658": "AB888X", + "37659": "AB888X", + "37660": "AB888X", + "37662": "AB888X", + "37663": "AB888X", + "37664": "AB888X", + "37665": "AB888X", + "37669": "AB888X", + "37680": "AB888X", + "37681": "AB888X", + "37682": "AB888X", + "37683": "AB887X", + "37684": "AB888X", + "37686": "AB888X", + "37687": "AB888X", + "37688": "AB888X", + "37690": "AB888X", + "37691": "AB888X", + "37692": "AB888X", + "37694": "AB888X", + "37699": "AB888X", + "37701": "AB888X", + "37705": "AB888X", + "37707": "AB888X", + "37708": "AB888X", + "37709": "AB888X", + "37710": "AB888X", + "37711": "AB888X", + "37713": "AB888X", + "37714": "AB888X", + "37715": "AB888X", + "37716": "AB888X", + "37717": "AB888X", + "37719": "AB888X", + "37721": "AB888X", + "37722": "AB888X", + "37723": "AB888X", + "37724": "AB888X", + "37725": "AB888X", + "37726": "AB888X", + "37727": "AB888X", + "37729": "AB888X", + "37730": "AB888X", + "37731": "AB888X", + "37732": "AB888X", + "37733": "AB888X", + "37737": "AB888X", + "37738": "AB888X", + "37742": "AB888X", + "37743": "AB888X", + "37744": "AB888X", + "37745": "AB888X", + "37748": "AB888X", + "37752": "AB888X", + "37753": "AB888X", + "37754": "AB888X", + "37755": "AB888X", + "37756": "AB888X", + "37757": "AB888X", + "37760": "AB888X", + "37762": "AB888X", + "37763": "AB888X", + "37764": "AB888X", + "37765": "AB888X", + "37766": "AB888X", + "37769": "AB888X", + "37770": "AB888X", + "37771": "AB888X", + "37772": "AB888X", + "37773": "AB888X", + "37774": "AB888X", + "37777": "AB888X", + "37778": "AB888X", + "37779": "AB888X", + "37801": "AB888X", + "37802": "AB888X", + "37803": "AB888X", + "37804": "AB888X", + "37806": "AB888X", + "37807": "AB888X", + "37809": "AB888X", + "37810": "AB888X", + "37811": "AB888X", + "37813": "AB888X", + "37814": "AB888X", + "37815": "AB888X", + "37816": "AB888X", + "37818": "AB888X", + "37819": "AB888X", + "37820": "AB888X", + "37821": "AB888X", + "37822": "AB888X", + "37824": "AB888X", + "37825": "AB888X", + "37826": "AB888X", + "37828": "AB888X", + "37829": "AB888X", + "37830": "AB888X", + "37831": "AB888X", + "37840": "AB888X", + "37841": "AB888X", + "37843": "AB888X", + "37845": "AB888X", + "37846": "AB888X", + "37847": "AB888X", + "37848": "AB888X", + "37849": "AB888X", + "37851": "AB888X", + "37852": "AB888X", + "37853": "AB888X", + "37854": "AB888X", + "37857": "AB888X", + "37860": "AB888X", + "37861": "AB888X", + "37862": "AB888X", + "37863": "AB888X", + "37864": "AB888X", + "37865": "AB888X", + "37866": "AB888X", + "37867": "AB888X", + "37868": "AB888X", + "37869": "AB888X", + "37870": "AB888X", + "37871": "AB888X", + "37872": "AB888X", + "37873": "AB888X", + "37874": "AB888X", + "37876": "AB888X", + "37877": "AB888X", + "37878": "AB888X", + "37879": "AB888X", + "37880": "AB888X", + "37881": "AB888X", + "37882": "AB888X", + "37885": "AB888X", + "37886": "AB888X", + "37887": "AB888X", + "37888": "AB888X", + "37890": "AB888X", + "37891": "AB888X", + "37892": "AB888X", + "37901": "AB888X", + "37902": "AB888X", + "37909": "AB888X", + "37912": "AB888X", + "37914": "AB888X", + "37915": "AB888X", + "37916": "AB888X", + "37917": "AB888X", + "37918": "AB888X", + "37919": "AB888X", + "37920": "AB888X", + "37921": "AB888X", + "37922": "AB888X", + "37923": "AB888X", + "37924": "AB888X", + "37927": "AB888X", + "37928": "AB888X", + "37929": "AB888X", + "37930": "AB888X", + "37931": "AB888X", + "37932": "AB888X", + "37933": "AB888X", + "37934": "AB888X", + "37938": "AB888X", + "37939": "AB888X", + "37940": "AB888X", + "37950": "AB888X", + "37990": "AB888X", + "37995": "AB888X", + "37996": "AB888X", + "37997": "AB888X", + "37998": "AB888X", + "38001": "AB889X", + "38002": "AB889X", + "38004": "AB889X", + "38006": "AB889X", + "38007": "AB889X", + "38008": "AB889X", + "38010": "AB889X", + "38011": "AB889X", + "38012": "AB889X", + "38014": "AB889X", + "38015": "AB889X", + "38016": "AB889X", + "38017": "AB889X", + "38018": "AB889X", + "38019": "AB889X", + "38021": "AB889X", + "38023": "AB889X", + "38024": "AB889X", + "38025": "AB889X", + "38027": "AB889X", + "38028": "AB889X", + "38029": "AB889X", + "38030": "AB889X", + "38034": "AB889X", + "38036": "AB889X", + "38037": "AB889X", + "38039": "AB889X", + "38040": "AB889X", + "38041": "AB889X", + "38042": "AB889X", + "38044": "AB889X", + "38045": "AB889X", + "38046": "AB889X", + "38047": "AB889X", + "38048": "AB889X", + "38049": "AB889X", + "38050": "AB889X", + "38052": "AB889X", + "38053": "AB889X", + "38054": "AB889X", + "38055": "AB889X", + "38057": "AB889X", + "38058": "AB889X", + "38059": "AB889X", + "38060": "AB889X", + "38061": "AB889X", + "38063": "AB889X", + "38066": "AB889X", + "38067": "AB889X", + "38068": "AB889X", + "38069": "AB889X", + "38070": "AB889X", + "38071": "AB889X", + "38075": "AB889X", + "38076": "AB889X", + "38077": "AB889X", + "38079": "AB889X", + "38080": "AB889X", + "38083": "AB889X", + "38088": "AB889X", + "38101": "AB889X", + "38103": "AB889X", + "38104": "AB889X", + "38105": "AB889X", + "38106": "AB889X", + "38107": "AB889X", + "38108": "AB889X", + "38109": "AB889X", + "38110": "AB889X", + "38111": "AB889X", + "38112": "AB889X", + "38113": "AB889X", + "38114": "AB889X", + "38115": "AB889X", + "38116": "AB889X", + "38117": "AB889X", + "38118": "AB889X", + "38119": "AB889X", + "38120": "AB889X", + "38122": "AB889X", + "38124": "AB889X", + "38125": "AB889X", + "38126": "AB889X", + "38127": "AB889X", + "38128": "AB889X", + "38130": "AB889X", + "38131": "AB889X", + "38132": "AB889X", + "38133": "AB889X", + "38134": "AB889X", + "38135": "AB889X", + "38136": "AB889X", + "38137": "AB889X", + "38138": "AB889X", + "38139": "AB889X", + "38141": "AB889X", + "38142": "AB889X", + "38145": "AB889X", + "38147": "AB889X", + "38148": "AB889X", + "38150": "AB889X", + "38151": "AB889X", + "38152": "AB889X", + "38157": "AB889X", + "38159": "AB889X", + "38161": "AB889X", + "38163": "AB889X", + "38165": "AB889X", + "38166": "AB889X", + "38167": "AB889X", + "38168": "AB889X", + "38173": "AB889X", + "38174": "AB889X", + "38175": "AB889X", + "38177": "AB889X", + "38181": "AB889X", + "38182": "AB889X", + "38183": "AB889X", + "38184": "AB889X", + "38186": "AB889X", + "38187": "AB889X", + "38188": "AB889X", + "38190": "AB889X", + "38193": "AB889X", + "38194": "AB889X", + "38197": "AB889X", + "38201": "AB889X", + "38220": "AB889X", + "38221": "AB889X", + "38222": "AB889X", + "38223": "AB889X", + "38224": "AB889X", + "38225": "AB888X", + "38226": "AB888X", + "38227": "AB888X", + "38229": "AB889X", + "38230": "AB888X", + "38231": "AB889X", + "38232": "AB888X", + "38233": "AB889X", + "38235": "AB889X", + "38236": "AB889X", + "38237": "AB888X", + "38238": "AB888X", + "38240": "AB888X", + "38241": "AB888X", + "38242": "AB887X", + "38251": "AB888X", + "38253": "AB888X", + "38254": "AB888X", + "38255": "AB888X", + "38256": "AB889X", + "38257": "AB888X", + "38258": "AB889X", + "38259": "AB889X", + "38260": "AB888X", + "38261": "AB888X", + "38271": "AB888X", + "38281": "AB888X", + "38301": "AB889X", + "38302": "AB889X", + "38303": "AB889X", + "38305": "AB889X", + "38308": "AB889X", + "38310": "AB889X", + "38311": "AB889X", + "38313": "AB889X", + "38314": "AB889X", + "38315": "AB889X", + "38316": "AB889X", + "38317": "AB889X", + "38318": "AB889X", + "38320": "AB887X", + "38321": "AB889X", + "38324": "AB889X", + "38326": "AB889X", + "38327": "AB889X", + "38328": "AB889X", + "38329": "AB889X", + "38330": "AB889X", + "38331": "AB889X", + "38332": "AB889X", + "38333": "AB889X", + "38334": "AB889X", + "38336": "AB889X", + "38337": "AB889X", + "38338": "AB889X", + "38339": "AB889X", + "38340": "AB889X", + "38341": "AB889X", + "38342": "AB889X", + "38343": "AB889X", + "38344": "AB889X", + "38345": "AB889X", + "38346": "AB889X", + "38347": "AB889X", + "38348": "AB889X", + "38351": "AB889X", + "38352": "AB889X", + "38355": "AB889X", + "38356": "AB889X", + "38357": "AB889X", + "38358": "AB889X", + "38359": "AB889X", + "38361": "AB889X", + "38362": "AB889X", + "38363": "AB889X", + "38365": "AB889X", + "38366": "AB889X", + "38367": "AB889X", + "38368": "AB889X", + "38369": "AB889X", + "38370": "AB889X", + "38371": "AB889X", + "38372": "AB889X", + "38374": "AB889X", + "38375": "AB889X", + "38376": "AB889X", + "38377": "AB889X", + "38378": "AB889X", + "38379": "AB889X", + "38380": "AB889X", + "38381": "AB889X", + "38382": "AB889X", + "38387": "AB889X", + "38388": "AB889X", + "38389": "AB889X", + "38390": "AB889X", + "38391": "AB889X", + "38392": "AB889X", + "38393": "AB889X", + "38401": "AB887X", + "38402": "AB887X", + "38425": "AB889X", + "38449": "AB887X", + "38450": "AB889X", + "38451": "AB887X", + "38452": "AB889X", + "38453": "AB887X", + "38454": "AB887X", + "38455": "AB887X", + "38456": "AB887X", + "38457": "AB887X", + "38459": "AB887X", + "38460": "AB887X", + "38461": "AB887X", + "38462": "AB887X", + "38463": "AB887X", + "38464": "AB887X", + "38468": "AB887X", + "38469": "AB887X", + "38471": "AB889X", + "38472": "AB887X", + "38473": "AB887X", + "38474": "AB887X", + "38475": "AB889X", + "38476": "AB887X", + "38477": "AB887X", + "38478": "AB887X", + "38481": "AB887X", + "38482": "AB887X", + "38483": "AB887X", + "38485": "AB887X", + "38486": "AB887X", + "38487": "AB887X", + "38488": "AB887X", + "38501": "AB887X", + "38502": "AB887X", + "38503": "AB887X", + "38504": "AB888X", + "38505": "AB887X", + "38506": "AB887X", + "38541": "AB887X", + "38542": "AB887X", + "38543": "AB888X", + "38544": "AB887X", + "38545": "AB887X", + "38547": "AB887X", + "38548": "AB887X", + "38549": "AB888X", + "38550": "AB887X", + "38551": "AB887X", + "38552": "AB887X", + "38553": "AB888X", + "38554": "AB887X", + "38555": "AB888X", + "38556": "AB888X", + "38557": "AB888X", + "38558": "AB888X", + "38559": "AB887X", + "38560": "AB887X", + "38562": "AB887X", + "38563": "AB887X", + "38564": "AB887X", + "38565": "AB888X", + "38567": "AB887X", + "38568": "AB887X", + "38569": "AB887X", + "38570": "AB887X", + "38571": "AB888X", + "38572": "AB888X", + "38573": "AB887X", + "38574": "AB887X", + "38575": "AB887X", + "38577": "AB888X", + "38578": "AB888X", + "38579": "AB887X", + "38580": "AB887X", + "38581": "AB887X", + "38582": "AB887X", + "38583": "AB887X", + "38585": "AB887X", + "38587": "AB887X", + "38588": "AB887X", + "38589": "AB887X", + "38601": "AB889X", + "38602": "AB889X", + "38603": "AB889X", + "38606": "AB889X", + "38609": "AB889X", + "38610": "AB889X", + "38611": "AB889X", + "38614": "AB889X", + "38617": "AB889X", + "38618": "AB889X", + "38619": "AB889X", + "38620": "AB889X", + "38621": "AB889X", + "38622": "AB889X", + "38623": "AB889X", + "38625": "AB889X", + "38626": "AB889X", + "38627": "AB889X", + "38628": "AB889X", + "38629": "AB889X", + "38630": "AB889X", + "38631": "AB889X", + "38632": "AB889X", + "38633": "AB889X", + "38634": "AB889X", + "38635": "AB889X", + "38637": "AB889X", + "38638": "AB889X", + "38639": "AB889X", + "38641": "AB889X", + "38642": "AB889X", + "38643": "AB889X", + "38644": "AB889X", + "38645": "AB889X", + "38646": "AB889X", + "38647": "AB889X", + "38649": "AB889X", + "38650": "AB889X", + "38651": "AB889X", + "38652": "AB889X", + "38654": "AB889X", + "38655": "AB889X", + "38658": "AB889X", + "38659": "AB889X", + "38661": "AB889X", + "38663": "AB889X", + "38664": "AB889X", + "38665": "AB889X", + "38666": "AB889X", + "38668": "AB889X", + "38669": "AB889X", + "38670": "AB889X", + "38671": "AB889X", + "38672": "AB889X", + "38673": "AB889X", + "38674": "AB889X", + "38675": "AB889X", + "38676": "AB889X", + "38677": "AB889X", + "38679": "AB889X", + "38680": "AB889X", + "38683": "AB889X", + "38685": "AB889X", + "38686": "AB889X", + "38701": "AB889X", + "38702": "AB889X", + "38703": "AB889X", + "38704": "AB889X", + "38720": "AB889X", + "38721": "AB889X", + "38722": "AB889X", + "38723": "AB889X", + "38725": "AB889X", + "38726": "AB889X", + "38730": "AB889X", + "38731": "AB889X", + "38732": "AB889X", + "38733": "AB889X", + "38736": "AB889X", + "38737": "AB889X", + "38738": "AB889X", + "38739": "AB889X", + "38740": "AB889X", + "38744": "AB889X", + "38745": "AB889X", + "38746": "AB889X", + "38748": "AB889X", + "38749": "AB889X", + "38751": "AB889X", + "38753": "AB889X", + "38754": "AB889X", + "38756": "AB889X", + "38759": "AB889X", + "38760": "AB889X", + "38761": "AB889X", + "38762": "AB889X", + "38764": "AB889X", + "38765": "AB889X", + "38767": "AB889X", + "38768": "AB889X", + "38769": "AB889X", + "38771": "AB889X", + "38772": "AB889X", + "38773": "AB889X", + "38774": "AB889X", + "38776": "AB889X", + "38778": "AB889X", + "38780": "AB889X", + "38781": "AB889X", + "38782": "AB889X", + "38801": "AB889X", + "38802": "AB889X", + "38803": "AB889X", + "38804": "AB889X", + "38820": "AB889X", + "38821": "AB889X", + "38824": "AB889X", + "38825": "AB889X", + "38826": "AB889X", + "38827": "AB889X", + "38828": "AB889X", + "38829": "AB889X", + "38833": "AB889X", + "38834": "AB889X", + "38835": "AB889X", + "38838": "AB889X", + "38839": "AB889X", + "38841": "AB889X", + "38843": "AB889X", + "38844": "AB889X", + "38846": "AB889X", + "38847": "AB889X", + "38848": "AB889X", + "38849": "AB889X", + "38850": "AB889X", + "38851": "AB889X", + "38852": "AB889X", + "38855": "AB889X", + "38856": "AB889X", + "38857": "AB889X", + "38858": "AB889X", + "38859": "AB889X", + "38860": "AB889X", + "38862": "AB889X", + "38863": "AB889X", + "38864": "AB889X", + "38865": "AB889X", + "38866": "AB889X", + "38868": "AB889X", + "38869": "AB889X", + "38870": "AB889X", + "38871": "AB889X", + "38873": "AB889X", + "38874": "AB889X", + "38875": "AB889X", + "38876": "AB889X", + "38877": "AB889X", + "38878": "AB889X", + "38879": "AB889X", + "38880": "AB889X", + "38901": "AB889X", + "38902": "AB889X", + "38913": "AB889X", + "38914": "AB889X", + "38915": "AB889X", + "38916": "AB889X", + "38917": "AB889X", + "38920": "AB889X", + "38921": "AB889X", + "38922": "AB889X", + "38923": "AB889X", + "38924": "AB889X", + "38925": "AB889X", + "38926": "AB889X", + "38927": "AB889X", + "38928": "AB889X", + "38929": "AB889X", + "38930": "AB889X", + "38935": "AB889X", + "38940": "AB889X", + "38941": "AB889X", + "38943": "AB889X", + "38944": "AB889X", + "38945": "AB889X", + "38946": "AB889X", + "38947": "AB889X", + "38948": "AB889X", + "38949": "AB889X", + "38950": "AB889X", + "38951": "AB889X", + "38952": "AB889X", + "38953": "AB889X", + "38954": "AB889X", + "38955": "AB889X", + "38957": "AB889X", + "38958": "AB889X", + "38959": "AB889X", + "38960": "AB889X", + "38961": "AB889X", + "38962": "AB889X", + "38963": "AB889X", + "38964": "AB889X", + "38965": "AB889X", + "38966": "AB889X", + "38967": "AB889X", + "39000": "AB889X", + "39038": "AB889X", + "39039": "AB889X", + "39040": "AB889X", + "39041": "AB889X", + "39042": "AB889X", + "39043": "AB889X", + "39044": "AB889X", + "39045": "AB889X", + "39046": "AB889X", + "39047": "AB889X", + "39051": "AB889X", + "39054": "AB889X", + "39056": "AB889X", + "39057": "AB889X", + "39058": "AB889X", + "39059": "AB889X", + "39060": "AB889X", + "39061": "AB889X", + "39062": "AB889X", + "39063": "AB889X", + "39066": "AB889X", + "39067": "AB889X", + "39069": "AB889X", + "39071": "AB889X", + "39072": "AB889X", + "39073": "AB889X", + "39074": "AB889X", + "39077": "AB889X", + "39078": "AB889X", + "39079": "AB889X", + "39080": "AB889X", + "39081": "AB889X", + "39082": "AB889X", + "39083": "AB889X", + "39086": "AB889X", + "39087": "AB889X", + "39088": "AB889X", + "39090": "AB889X", + "39092": "AB889X", + "39094": "AB889X", + "39095": "AB889X", + "39096": "AB889X", + "39097": "AB889X", + "39098": "AB889X", + "39107": "AB889X", + "39108": "AB889X", + "39109": "AB889X", + "39110": "AB889X", + "39111": "AB889X", + "39113": "AB889X", + "39114": "AB889X", + "39115": "AB889X", + "39116": "AB889X", + "39117": "AB889X", + "39119": "AB889X", + "39120": "AB887X", + "39121": "AB887X", + "39122": "AB887X", + "39130": "AB889X", + "39140": "AB889X", + "39144": "AB889X", + "39145": "AB889X", + "39146": "AB889X", + "39148": "AB889X", + "39149": "AB889X", + "39150": "AB889X", + "39151": "AB889X", + "39152": "AB889X", + "39153": "AB889X", + "39154": "AB889X", + "39156": "AB889X", + "39157": "AB889X", + "39158": "AB889X", + "39159": "AB889X", + "39160": "AB889X", + "39161": "AB889X", + "39162": "AB889X", + "39163": "AB889X", + "39165": "AB887X", + "39166": "AB889X", + "39167": "AB889X", + "39168": "AB889X", + "39169": "AB889X", + "39170": "AB889X", + "39171": "AB889X", + "39173": "AB889X", + "39174": "AB889X", + "39175": "AB889X", + "39176": "AB889X", + "39177": "AB889X", + "39179": "AB889X", + "39180": "AB889X", + "39181": "AB889X", + "39182": "AB889X", + "39183": "AB889X", + "39189": "AB889X", + "39190": "AB887X", + "39191": "AB889X", + "39192": "AB889X", + "39193": "AB889X", + "39194": "AB889X", + "39201": "AB889X", + "39202": "AB889X", + "39203": "AB889X", + "39204": "AB889X", + "39205": "AB889X", + "39206": "AB889X", + "39207": "AB889X", + "39208": "AB889X", + "39209": "AB889X", + "39210": "AB889X", + "39211": "AB889X", + "39212": "AB889X", + "39213": "AB889X", + "39215": "AB889X", + "39216": "AB889X", + "39217": "AB889X", + "39218": "AB889X", + "39225": "AB889X", + "39232": "AB889X", + "39235": "AB889X", + "39236": "AB889X", + "39250": "AB889X", + "39269": "AB889X", + "39271": "AB889X", + "39272": "AB889X", + "39282": "AB889X", + "39283": "AB889X", + "39284": "AB889X", + "39286": "AB889X", + "39288": "AB889X", + "39289": "AB889X", + "39296": "AB889X", + "39298": "AB889X", + "39301": "AB889X", + "39302": "AB889X", + "39303": "AB889X", + "39304": "AB889X", + "39305": "AB889X", + "39307": "AB889X", + "39309": "AB889X", + "39320": "AB889X", + "39322": "AB889X", + "39323": "AB889X", + "39324": "AB889X", + "39325": "AB889X", + "39326": "AB889X", + "39327": "AB889X", + "39328": "AB889X", + "39330": "AB889X", + "39332": "AB889X", + "39335": "AB889X", + "39336": "AB889X", + "39337": "AB889X", + "39338": "AB889X", + "39339": "AB889X", + "39341": "AB889X", + "39342": "AB889X", + "39345": "AB889X", + "39346": "AB889X", + "39347": "AB889X", + "39348": "AB889X", + "39350": "AB889X", + "39351": "AB889X", + "39352": "AB889X", + "39354": "AB889X", + "39355": "AB889X", + "39356": "AB889X", + "39358": "AB889X", + "39359": "AB889X", + "39360": "AB889X", + "39361": "AB889X", + "39362": "AB889X", + "39363": "AB889X", + "39364": "AB889X", + "39365": "AB889X", + "39366": "AB889X", + "39367": "AB889X", + "39391": "AB889X", + "39392": "AB889X", + "39401": "AB889X", + "39402": "AB889X", + "39403": "AB889X", + "39404": "AB889X", + "39406": "AB889X", + "39407": "AB889X", + "39421": "AB889X", + "39422": "AB889X", + "39423": "AB889X", + "39425": "AB889X", + "39426": "AB889X", + "39427": "AB889X", + "39428": "AB889X", + "39429": "AB889X", + "39436": "AB889X", + "39437": "AB889X", + "39439": "AB889X", + "39440": "AB889X", + "39441": "AB889X", + "39442": "AB889X", + "39443": "AB889X", + "39451": "AB889X", + "39452": "AB889X", + "39455": "AB889X", + "39456": "AB889X", + "39457": "AB889X", + "39459": "AB889X", + "39460": "AB889X", + "39461": "AB889X", + "39462": "AB889X", + "39463": "AB889X", + "39464": "AB889X", + "39465": "AB889X", + "39466": "AB889X", + "39470": "AB889X", + "39474": "AB889X", + "39475": "AB889X", + "39476": "AB889X", + "39477": "AB889X", + "39478": "AB889X", + "39479": "AB889X", + "39480": "AB889X", + "39481": "AB889X", + "39482": "AB889X", + "39483": "AB889X", + "39501": "AB889X", + "39502": "AB889X", + "39503": "AB889X", + "39505": "AB889X", + "39506": "AB889X", + "39507": "AB889X", + "39520": "AB889X", + "39521": "AB889X", + "39522": "AB889X", + "39525": "AB889X", + "39529": "AB889X", + "39530": "AB889X", + "39531": "AB889X", + "39532": "AB889X", + "39533": "AB889X", + "39534": "AB889X", + "39535": "AB889X", + "39540": "AB889X", + "39552": "AB889X", + "39553": "AB889X", + "39555": "AB889X", + "39556": "AB889X", + "39558": "AB889X", + "39560": "AB889X", + "39561": "AB889X", + "39562": "AB889X", + "39563": "AB889X", + "39564": "AB889X", + "39565": "AB889X", + "39566": "AB889X", + "39567": "AB889X", + "39568": "AB889X", + "39569": "AB889X", + "39571": "AB889X", + "39572": "AB889X", + "39573": "AB889X", + "39574": "AB889X", + "39576": "AB889X", + "39577": "AB889X", + "39581": "AB889X", + "39595": "AB889X", + "39601": "AB889X", + "39602": "AB889X", + "39603": "AB889X", + "39626": "AB889X", + "39629": "AB889X", + "39630": "AB889X", + "39631": "AB889X", + "39632": "AB889X", + "39633": "AB889X", + "39635": "AB889X", + "39638": "AB889X", + "39641": "AB889X", + "39643": "AB889X", + "39645": "AB889X", + "39647": "AB889X", + "39648": "AB889X", + "39649": "AB889X", + "39652": "AB889X", + "39653": "AB889X", + "39654": "AB889X", + "39656": "AB889X", + "39657": "AB889X", + "39661": "AB889X", + "39662": "AB889X", + "39663": "AB889X", + "39664": "AB889X", + "39665": "AB889X", + "39666": "AB889X", + "39667": "AB889X", + "39668": "AB889X", + "39669": "AB889X", + "39701": "AB889X", + "39702": "AB889X", + "39703": "AB889X", + "39704": "AB889X", + "39705": "AB889X", + "39710": "AB889X", + "39730": "AB889X", + "39733": "AB889X", + "39735": "AB889X", + "39736": "AB889X", + "39737": "AB889X", + "39739": "AB889X", + "39740": "AB889X", + "39741": "AB889X", + "39743": "AB889X", + "39744": "AB889X", + "39745": "AB889X", + "39746": "AB889X", + "39747": "AB889X", + "39750": "AB889X", + "39751": "AB889X", + "39752": "AB889X", + "39753": "AB889X", + "39754": "AB889X", + "39755": "AB889X", + "39756": "AB889X", + "39759": "AB889X", + "39760": "AB889X", + "39762": "AB889X", + "39766": "AB889X", + "39767": "AB889X", + "39769": "AB889X", + "39771": "AB889X", + "39772": "AB889X", + "39773": "AB889X", + "39776": "AB889X", + "39813": "AB891X", + "39815": "AB891X", + "39817": "AB891X", + "39818": "AB891X", + "39819": "AB891X", + "39823": "AB890X", + "39824": "AB890X", + "39825": "AB891X", + "39826": "AB891X", + "39827": "AB891X", + "39828": "AB891X", + "39829": "AB891X", + "39832": "AB890X", + "39834": "AB891X", + "39836": "AB890X", + "39837": "AB891X", + "39840": "AB890X", + "39841": "AB890X", + "39842": "AB891X", + "39845": "AB891X", + "39846": "AB891X", + "39851": "AB890X", + "39852": "AB891X", + "39854": "AB890X", + "39859": "AB891X", + "39861": "AB890X", + "39862": "AB891X", + "39866": "AB891X", + "39867": "AB890X", + "39870": "AB891X", + "39877": "AB891X", + "39885": "AB891X", + "39886": "AB890X", + "39897": "AB891X", + "39901": "AB889X", + "40003": "AB888X", + "40004": "AB888X", + "40006": "AB888X", + "40007": "AB888X", + "40008": "AB888X", + "40009": "AB888X", + "40010": "AB888X", + "40011": "AB888X", + "40012": "AB888X", + "40013": "AB888X", + "40014": "AB888X", + "40018": "AB888X", + "40019": "AB888X", + "40020": "AB888X", + "40022": "AB888X", + "40023": "AB888X", + "40025": "AB888X", + "40026": "AB888X", + "40027": "AB888X", + "40031": "AB888X", + "40032": "AB888X", + "40033": "AB888X", + "40036": "AB888X", + "40037": "AB888X", + "40040": "AB888X", + "40041": "AB888X", + "40045": "AB888X", + "40046": "AB888X", + "40047": "AB888X", + "40048": "AB888X", + "40049": "AB888X", + "40050": "AB888X", + "40051": "AB888X", + "40052": "AB888X", + "40055": "AB888X", + "40056": "AB888X", + "40057": "AB888X", + "40058": "AB888X", + "40059": "AB888X", + "40060": "AB888X", + "40061": "AB888X", + "40062": "AB888X", + "40063": "AB888X", + "40065": "AB888X", + "40066": "AB888X", + "40067": "AB888X", + "40068": "AB888X", + "40069": "AB888X", + "40070": "AB888X", + "40071": "AB888X", + "40075": "AB888X", + "40076": "AB888X", + "40077": "AB888X", + "40078": "AB888X", + "40104": "AB888X", + "40107": "AB888X", + "40108": "AB888X", + "40109": "AB888X", + "40110": "AB888X", + "40111": "AB888X", + "40115": "AB888X", + "40117": "AB888X", + "40118": "AB888X", + "40119": "AB888X", + "40121": "AB888X", + "40129": "AB888X", + "40140": "AB888X", + "40142": "AB888X", + "40143": "AB888X", + "40144": "AB888X", + "40145": "AB888X", + "40146": "AB888X", + "40150": "AB888X", + "40152": "AB888X", + "40153": "AB888X", + "40155": "AB888X", + "40157": "AB888X", + "40159": "AB888X", + "40160": "AB888X", + "40161": "AB888X", + "40162": "AB888X", + "40165": "AB888X", + "40170": "AB888X", + "40171": "AB888X", + "40175": "AB888X", + "40176": "AB888X", + "40177": "AB888X", + "40178": "AB888X", + "40201": "AB888X", + "40202": "AB888X", + "40203": "AB888X", + "40204": "AB888X", + "40205": "AB888X", + "40206": "AB888X", + "40207": "AB888X", + "40208": "AB888X", + "40209": "AB888X", + "40210": "AB888X", + "40211": "AB888X", + "40212": "AB888X", + "40213": "AB888X", + "40214": "AB888X", + "40215": "AB888X", + "40216": "AB888X", + "40217": "AB888X", + "40218": "AB888X", + "40219": "AB888X", + "40220": "AB888X", + "40221": "AB888X", + "40222": "AB888X", + "40223": "AB888X", + "40224": "AB888X", + "40225": "AB888X", + "40228": "AB888X", + "40229": "AB888X", + "40231": "AB888X", + "40232": "AB888X", + "40233": "AB888X", + "40241": "AB888X", + "40242": "AB888X", + "40243": "AB888X", + "40245": "AB888X", + "40250": "AB888X", + "40251": "AB888X", + "40252": "AB888X", + "40253": "AB888X", + "40255": "AB888X", + "40256": "AB888X", + "40257": "AB888X", + "40258": "AB888X", + "40259": "AB888X", + "40261": "AB888X", + "40266": "AB888X", + "40268": "AB888X", + "40269": "AB888X", + "40270": "AB888X", + "40272": "AB888X", + "40280": "AB888X", + "40281": "AB888X", + "40282": "AB888X", + "40283": "AB888X", + "40285": "AB888X", + "40287": "AB888X", + "40289": "AB888X", + "40290": "AB888X", + "40291": "AB888X", + "40292": "AB888X", + "40293": "AB888X", + "40294": "AB888X", + "40295": "AB888X", + "40296": "AB888X", + "40297": "AB888X", + "40298": "AB888X", + "40299": "AB888X", + "40310": "AB888X", + "40311": "AB888X", + "40312": "AB888X", + "40313": "AB888X", + "40316": "AB888X", + "40317": "AB888X", + "40319": "AB888X", + "40322": "AB888X", + "40324": "AB888X", + "40328": "AB888X", + "40330": "AB888X", + "40334": "AB888X", + "40336": "AB888X", + "40337": "AB888X", + "40339": "AB888X", + "40340": "AB888X", + "40342": "AB888X", + "40346": "AB888X", + "40347": "AB888X", + "40348": "AB888X", + "40350": "AB888X", + "40351": "AB888X", + "40353": "AB888X", + "40355": "AB890X", + "40356": "AB888X", + "40357": "AB888X", + "40358": "AB888X", + "40359": "AB890X", + "40360": "AB888X", + "40361": "AB888X", + "40362": "AB888X", + "40363": "AB890X", + "40366": "AB888X", + "40370": "AB888X", + "40371": "AB888X", + "40372": "AB888X", + "40374": "AB888X", + "40376": "AB888X", + "40379": "AB888X", + "40380": "AB888X", + "40383": "AB888X", + "40384": "AB888X", + "40385": "AB888X", + "40386": "AB888X", + "40387": "AB888X", + "40390": "AB888X", + "40391": "AB888X", + "40392": "AB888X", + "40400": "AB888X", + "40402": "AB888X", + "40403": "AB888X", + "40404": "AB888X", + "40405": "AB888X", + "40409": "AB888X", + "40410": "AB888X", + "40419": "AB888X", + "40422": "AB888X", + "40423": "AB888X", + "40427": "AB888X", + "40434": "AB888X", + "40437": "AB888X", + "40440": "AB888X", + "40442": "AB888X", + "40444": "AB888X", + "40445": "AB888X", + "40446": "AB888X", + "40447": "AB888X", + "40448": "AB888X", + "40452": "AB888X", + "40456": "AB888X", + "40460": "AB888X", + "40461": "AB888X", + "40464": "AB888X", + "40468": "AB888X", + "40472": "AB888X", + "40473": "AB888X", + "40475": "AB888X", + "40476": "AB888X", + "40481": "AB888X", + "40484": "AB888X", + "40486": "AB888X", + "40488": "AB888X", + "40489": "AB888X", + "40492": "AB888X", + "40495": "AB888X", + "40501": "AB888X", + "40502": "AB888X", + "40503": "AB888X", + "40504": "AB888X", + "40505": "AB888X", + "40506": "AB888X", + "40507": "AB888X", + "40508": "AB888X", + "40509": "AB888X", + "40510": "AB888X", + "40511": "AB888X", + "40512": "AB888X", + "40513": "AB888X", + "40514": "AB888X", + "40515": "AB888X", + "40516": "AB888X", + "40517": "AB888X", + "40522": "AB888X", + "40523": "AB888X", + "40524": "AB888X", + "40526": "AB888X", + "40533": "AB888X", + "40536": "AB888X", + "40544": "AB888X", + "40546": "AB888X", + "40550": "AB888X", + "40555": "AB888X", + "40574": "AB888X", + "40575": "AB888X", + "40576": "AB888X", + "40577": "AB888X", + "40578": "AB888X", + "40579": "AB888X", + "40580": "AB888X", + "40581": "AB888X", + "40582": "AB888X", + "40583": "AB888X", + "40585": "AB888X", + "40588": "AB888X", + "40591": "AB888X", + "40598": "AB888X", + "40601": "AB888X", + "40602": "AB888X", + "40603": "AB888X", + "40604": "AB888X", + "40618": "AB888X", + "40619": "AB888X", + "40620": "AB888X", + "40621": "AB888X", + "40622": "AB888X", + "40701": "AB888X", + "40702": "AB888X", + "40724": "AB888X", + "40729": "AB888X", + "40730": "AB888X", + "40734": "AB888X", + "40737": "AB888X", + "40740": "AB888X", + "40741": "AB888X", + "40742": "AB888X", + "40743": "AB888X", + "40744": "AB888X", + "40745": "AB888X", + "40754": "AB888X", + "40755": "AB888X", + "40759": "AB888X", + "40763": "AB888X", + "40769": "AB888X", + "40771": "AB888X", + "40801": "AB888X", + "40803": "AB888X", + "40806": "AB888X", + "40807": "AB888X", + "40808": "AB888X", + "40810": "AB888X", + "40813": "AB888X", + "40815": "AB888X", + "40816": "AB888X", + "40818": "AB888X", + "40819": "AB888X", + "40820": "AB888X", + "40823": "AB888X", + "40824": "AB888X", + "40826": "AB888X", + "40827": "AB888X", + "40828": "AB888X", + "40829": "AB888X", + "40830": "AB888X", + "40831": "AB888X", + "40840": "AB888X", + "40843": "AB888X", + "40844": "AB888X", + "40845": "AB888X", + "40847": "AB888X", + "40849": "AB888X", + "40854": "AB888X", + "40855": "AB888X", + "40856": "AB888X", + "40858": "AB888X", + "40862": "AB888X", + "40863": "AB888X", + "40865": "AB888X", + "40868": "AB888X", + "40870": "AB888X", + "40873": "AB888X", + "40874": "AB888X", + "40902": "AB888X", + "40903": "AB888X", + "40906": "AB888X", + "40913": "AB888X", + "40914": "AB888X", + "40915": "AB888X", + "40921": "AB888X", + "40923": "AB888X", + "40927": "AB888X", + "40930": "AB888X", + "40931": "AB888X", + "40932": "AB888X", + "40935": "AB888X", + "40939": "AB888X", + "40940": "AB888X", + "40941": "AB888X", + "40943": "AB888X", + "40944": "AB888X", + "40946": "AB888X", + "40949": "AB888X", + "40951": "AB888X", + "40953": "AB888X", + "40955": "AB888X", + "40958": "AB888X", + "40962": "AB888X", + "40964": "AB888X", + "40965": "AB888X", + "40972": "AB888X", + "40977": "AB888X", + "40979": "AB888X", + "40981": "AB888X", + "40982": "AB888X", + "40983": "AB888X", + "40988": "AB888X", + "40995": "AB888X", + "40997": "AB888X", + "40999": "AB888X", + "41001": "AB890X", + "41002": "AB890X", + "41003": "AB888X", + "41004": "AB890X", + "41005": "AB890X", + "41006": "AB888X", + "41007": "AB888X", + "41008": "AB888X", + "41010": "AB890X", + "41011": "AB890X", + "41012": "AB890X", + "41014": "AB890X", + "41015": "AB890X", + "41016": "AB890X", + "41017": "AB890X", + "41018": "AB890X", + "41019": "AB890X", + "41022": "AB890X", + "41030": "AB890X", + "41031": "AB888X", + "41033": "AB890X", + "41034": "AB890X", + "41035": "AB890X", + "41037": "AB890X", + "41039": "AB890X", + "41040": "AB890X", + "41041": "AB890X", + "41042": "AB890X", + "41043": "AB890X", + "41044": "AB890X", + "41045": "AB888X", + "41046": "AB890X", + "41048": "AB890X", + "41049": "AB890X", + "41051": "AB890X", + "41052": "AB890X", + "41053": "AB890X", + "41054": "AB890X", + "41055": "AB890X", + "41056": "AB890X", + "41059": "AB888X", + "41061": "AB888X", + "41062": "AB890X", + "41063": "AB890X", + "41064": "AB890X", + "41065": "AB890X", + "41071": "AB888X", + "41072": "AB888X", + "41073": "AB888X", + "41074": "AB888X", + "41075": "AB888X", + "41076": "AB888X", + "41080": "AB890X", + "41081": "AB890X", + "41083": "AB888X", + "41085": "AB888X", + "41086": "AB890X", + "41091": "AB890X", + "41092": "AB890X", + "41093": "AB890X", + "41094": "AB890X", + "41095": "AB890X", + "41096": "AB890X", + "41097": "AB890X", + "41098": "AB888X", + "41099": "AB888X", + "41101": "AB900X", + "41102": "AB900X", + "41105": "AB900X", + "41114": "AB900X", + "41121": "AB900X", + "41124": "AB900X", + "41128": "AB888X", + "41129": "AB900X", + "41132": "AB888X", + "41135": "AB890X", + "41139": "AB900X", + "41141": "AB900X", + "41142": "AB888X", + "41143": "AB900X", + "41144": "AB900X", + "41146": "AB888X", + "41149": "AB900X", + "41159": "AB900X", + "41160": "AB900X", + "41164": "AB900X", + "41166": "AB890X", + "41168": "AB900X", + "41169": "AB900X", + "41171": "AB900X", + "41173": "AB900X", + "41174": "AB900X", + "41175": "AB900X", + "41179": "AB890X", + "41180": "AB900X", + "41181": "AB900X", + "41183": "AB900X", + "41189": "AB890X", + "41201": "AB900X", + "41203": "AB900X", + "41204": "AB900X", + "41214": "AB900X", + "41216": "AB900X", + "41219": "AB900X", + "41222": "AB900X", + "41224": "AB900X", + "41226": "AB900X", + "41230": "AB900X", + "41231": "AB900X", + "41232": "AB900X", + "41234": "AB900X", + "41235": "AB900X", + "41238": "AB900X", + "41240": "AB900X", + "41250": "AB900X", + "41254": "AB900X", + "41255": "AB900X", + "41256": "AB900X", + "41257": "AB900X", + "41260": "AB900X", + "41262": "AB900X", + "41263": "AB900X", + "41264": "AB900X", + "41265": "AB900X", + "41267": "AB900X", + "41268": "AB900X", + "41271": "AB900X", + "41274": "AB900X", + "41301": "AB888X", + "41307": "AB888X", + "41310": "AB888X", + "41311": "AB888X", + "41313": "AB888X", + "41314": "AB888X", + "41317": "AB888X", + "41332": "AB888X", + "41333": "AB888X", + "41338": "AB888X", + "41339": "AB888X", + "41347": "AB888X", + "41348": "AB888X", + "41351": "AB888X", + "41352": "AB900X", + "41360": "AB888X", + "41362": "AB888X", + "41364": "AB888X", + "41365": "AB888X", + "41366": "AB888X", + "41367": "AB888X", + "41368": "AB888X", + "41385": "AB888X", + "41386": "AB888X", + "41390": "AB888X", + "41397": "AB888X", + "41408": "AB900X", + "41413": "AB900X", + "41421": "AB900X", + "41425": "AB900X", + "41426": "AB900X", + "41433": "AB900X", + "41451": "AB900X", + "41459": "AB900X", + "41464": "AB900X", + "41465": "AB900X", + "41472": "AB900X", + "41477": "AB900X", + "41501": "AB900X", + "41502": "AB900X", + "41503": "AB900X", + "41512": "AB900X", + "41513": "AB900X", + "41514": "AB900X", + "41517": "AB900X", + "41519": "AB900X", + "41520": "AB900X", + "41522": "AB900X", + "41524": "AB900X", + "41526": "AB900X", + "41527": "AB900X", + "41528": "AB900X", + "41531": "AB900X", + "41534": "AB900X", + "41535": "AB900X", + "41537": "AB888X", + "41538": "AB900X", + "41539": "AB900X", + "41540": "AB900X", + "41542": "AB900X", + "41543": "AB900X", + "41544": "AB900X", + "41547": "AB900X", + "41548": "AB900X", + "41549": "AB900X", + "41553": "AB900X", + "41554": "AB900X", + "41555": "AB900X", + "41557": "AB900X", + "41558": "AB900X", + "41559": "AB900X", + "41560": "AB900X", + "41561": "AB900X", + "41562": "AB900X", + "41563": "AB900X", + "41564": "AB900X", + "41566": "AB900X", + "41567": "AB900X", + "41568": "AB900X", + "41571": "AB900X", + "41572": "AB900X", + "41601": "AB900X", + "41602": "AB900X", + "41603": "AB900X", + "41604": "AB900X", + "41605": "AB900X", + "41606": "AB900X", + "41607": "AB900X", + "41612": "AB900X", + "41615": "AB900X", + "41616": "AB900X", + "41619": "AB900X", + "41621": "AB900X", + "41622": "AB900X", + "41630": "AB900X", + "41631": "AB900X", + "41632": "AB900X", + "41635": "AB900X", + "41636": "AB900X", + "41640": "AB900X", + "41642": "AB900X", + "41643": "AB900X", + "41645": "AB900X", + "41647": "AB900X", + "41649": "AB900X", + "41650": "AB900X", + "41651": "AB900X", + "41653": "AB900X", + "41655": "AB900X", + "41659": "AB900X", + "41660": "AB900X", + "41663": "AB900X", + "41666": "AB900X", + "41667": "AB900X", + "41669": "AB900X", + "41695": "AB900X", + "41701": "AB888X", + "41702": "AB888X", + "41712": "AB888X", + "41713": "AB888X", + "41714": "AB888X", + "41719": "AB888X", + "41721": "AB888X", + "41722": "AB888X", + "41723": "AB888X", + "41725": "AB900X", + "41727": "AB888X", + "41729": "AB888X", + "41731": "AB888X", + "41735": "AB888X", + "41736": "AB888X", + "41739": "AB888X", + "41740": "AB900X", + "41743": "AB900X", + "41745": "AB888X", + "41746": "AB888X", + "41747": "AB888X", + "41749": "AB888X", + "41751": "AB888X", + "41754": "AB888X", + "41759": "AB900X", + "41760": "AB888X", + "41762": "AB888X", + "41763": "AB888X", + "41764": "AB888X", + "41766": "AB888X", + "41772": "AB900X", + "41773": "AB888X", + "41774": "AB888X", + "41775": "AB888X", + "41776": "AB888X", + "41777": "AB888X", + "41778": "AB888X", + "41804": "AB888X", + "41810": "AB888X", + "41812": "AB888X", + "41815": "AB888X", + "41817": "AB900X", + "41819": "AB888X", + "41821": "AB888X", + "41822": "AB900X", + "41824": "AB888X", + "41825": "AB888X", + "41826": "AB888X", + "41828": "AB900X", + "41831": "AB900X", + "41832": "AB888X", + "41833": "AB888X", + "41834": "AB900X", + "41835": "AB888X", + "41836": "AB900X", + "41837": "AB888X", + "41838": "AB888X", + "41839": "AB900X", + "41840": "AB888X", + "41843": "AB900X", + "41844": "AB900X", + "41845": "AB888X", + "41847": "AB900X", + "41848": "AB888X", + "41849": "AB888X", + "41855": "AB888X", + "41858": "AB888X", + "41859": "AB900X", + "41861": "AB900X", + "41862": "AB900X", + "42001": "AB888X", + "42002": "AB888X", + "42003": "AB888X", + "42020": "AB888X", + "42021": "AB888X", + "42022": "AB888X", + "42023": "AB888X", + "42024": "AB888X", + "42025": "AB888X", + "42027": "AB888X", + "42028": "AB888X", + "42029": "AB888X", + "42031": "AB888X", + "42032": "AB888X", + "42033": "AB888X", + "42035": "AB888X", + "42036": "AB888X", + "42037": "AB888X", + "42038": "AB888X", + "42039": "AB888X", + "42040": "AB888X", + "42041": "AB888X", + "42044": "AB888X", + "42045": "AB888X", + "42047": "AB888X", + "42048": "AB888X", + "42049": "AB888X", + "42050": "AB888X", + "42051": "AB888X", + "42053": "AB888X", + "42054": "AB888X", + "42055": "AB888X", + "42056": "AB888X", + "42058": "AB888X", + "42060": "AB888X", + "42061": "AB888X", + "42063": "AB888X", + "42064": "AB888X", + "42066": "AB888X", + "42069": "AB888X", + "42070": "AB888X", + "42071": "AB888X", + "42076": "AB888X", + "42078": "AB888X", + "42079": "AB888X", + "42081": "AB888X", + "42082": "AB888X", + "42083": "AB888X", + "42084": "AB888X", + "42085": "AB888X", + "42086": "AB888X", + "42087": "AB888X", + "42088": "AB888X", + "42101": "AB887X", + "42102": "AB887X", + "42103": "AB887X", + "42104": "AB887X", + "42120": "AB887X", + "42122": "AB887X", + "42123": "AB887X", + "42124": "AB887X", + "42127": "AB887X", + "42128": "AB887X", + "42129": "AB887X", + "42130": "AB887X", + "42131": "AB887X", + "42133": "AB887X", + "42134": "AB887X", + "42135": "AB887X", + "42140": "AB887X", + "42141": "AB887X", + "42142": "AB887X", + "42151": "AB887X", + "42152": "AB887X", + "42153": "AB887X", + "42154": "AB887X", + "42156": "AB887X", + "42157": "AB887X", + "42159": "AB887X", + "42160": "AB887X", + "42163": "AB887X", + "42164": "AB887X", + "42166": "AB887X", + "42167": "AB887X", + "42170": "AB887X", + "42171": "AB887X", + "42201": "AB887X", + "42202": "AB887X", + "42204": "AB887X", + "42206": "AB887X", + "42207": "AB887X", + "42210": "AB887X", + "42211": "AB887X", + "42214": "AB887X", + "42215": "AB887X", + "42216": "AB887X", + "42217": "AB887X", + "42219": "AB887X", + "42220": "AB887X", + "42221": "AB887X", + "42223": "AB887X", + "42232": "AB887X", + "42234": "AB887X", + "42236": "AB887X", + "42240": "AB887X", + "42241": "AB887X", + "42252": "AB887X", + "42254": "AB887X", + "42256": "AB887X", + "42259": "AB887X", + "42261": "AB887X", + "42262": "AB887X", + "42265": "AB887X", + "42266": "AB887X", + "42273": "AB887X", + "42274": "AB887X", + "42275": "AB887X", + "42276": "AB887X", + "42280": "AB887X", + "42283": "AB887X", + "42285": "AB887X", + "42286": "AB887X", + "42287": "AB887X", + "42288": "AB887X", + "42301": "AB888X", + "42302": "AB888X", + "42303": "AB888X", + "42304": "AB888X", + "42320": "AB888X", + "42321": "AB888X", + "42322": "AB888X", + "42323": "AB888X", + "42324": "AB888X", + "42325": "AB888X", + "42326": "AB888X", + "42327": "AB888X", + "42328": "AB888X", + "42330": "AB888X", + "42332": "AB888X", + "42333": "AB888X", + "42334": "AB888X", + "42336": "AB888X", + "42337": "AB888X", + "42338": "AB888X", + "42339": "AB888X", + "42340": "AB888X", + "42343": "AB888X", + "42344": "AB888X", + "42345": "AB888X", + "42347": "AB888X", + "42348": "AB888X", + "42349": "AB888X", + "42350": "AB888X", + "42351": "AB888X", + "42352": "AB888X", + "42354": "AB888X", + "42355": "AB888X", + "42356": "AB888X", + "42358": "AB888X", + "42361": "AB888X", + "42364": "AB888X", + "42365": "AB888X", + "42366": "AB888X", + "42367": "AB888X", + "42368": "AB888X", + "42369": "AB888X", + "42370": "AB888X", + "42371": "AB888X", + "42372": "AB888X", + "42374": "AB888X", + "42375": "AB888X", + "42376": "AB888X", + "42377": "AB888X", + "42378": "AB888X", + "42402": "AB888X", + "42403": "AB888X", + "42404": "AB888X", + "42406": "AB888X", + "42408": "AB888X", + "42409": "AB888X", + "42410": "AB888X", + "42411": "AB888X", + "42413": "AB888X", + "42419": "AB888X", + "42420": "AB888X", + "42431": "AB888X", + "42436": "AB888X", + "42437": "AB888X", + "42440": "AB888X", + "42441": "AB888X", + "42442": "AB888X", + "42444": "AB888X", + "42445": "AB888X", + "42450": "AB888X", + "42451": "AB888X", + "42452": "AB888X", + "42453": "AB888X", + "42455": "AB888X", + "42456": "AB888X", + "42457": "AB888X", + "42458": "AB888X", + "42459": "AB888X", + "42460": "AB888X", + "42461": "AB888X", + "42462": "AB888X", + "42463": "AB888X", + "42464": "AB888X", + "42501": "AB888X", + "42502": "AB888X", + "42503": "AB888X", + "42516": "AB888X", + "42518": "AB888X", + "42519": "AB888X", + "42528": "AB888X", + "42533": "AB888X", + "42539": "AB888X", + "42541": "AB888X", + "42544": "AB888X", + "42553": "AB888X", + "42558": "AB888X", + "42564": "AB888X", + "42565": "AB888X", + "42566": "AB888X", + "42567": "AB888X", + "42602": "AB888X", + "42603": "AB888X", + "42629": "AB888X", + "42631": "AB888X", + "42633": "AB888X", + "42634": "AB888X", + "42635": "AB888X", + "42638": "AB888X", + "42642": "AB888X", + "42647": "AB888X", + "42649": "AB888X", + "42653": "AB888X", + "42701": "AB888X", + "42702": "AB888X", + "42712": "AB888X", + "42713": "AB887X", + "42715": "AB888X", + "42716": "AB888X", + "42717": "AB887X", + "42718": "AB888X", + "42719": "AB888X", + "42720": "AB888X", + "42721": "AB888X", + "42722": "AB887X", + "42724": "AB888X", + "42726": "AB888X", + "42728": "AB888X", + "42729": "AB887X", + "42731": "AB887X", + "42732": "AB888X", + "42733": "AB888X", + "42740": "AB888X", + "42741": "AB888X", + "42742": "AB888X", + "42743": "AB888X", + "42746": "AB887X", + "42748": "AB888X", + "42749": "AB887X", + "42753": "AB888X", + "42754": "AB888X", + "42755": "AB888X", + "42757": "AB888X", + "42758": "AB888X", + "42759": "AB887X", + "42762": "AB888X", + "42764": "AB888X", + "42765": "AB887X", + "42776": "AB888X", + "42782": "AB888X", + "42784": "AB888X", + "42788": "AB888X", + "43000": "AB890X", + "43001": "AB890X", + "43002": "AB890X", + "43003": "AB890X", + "43004": "AB890X", + "43005": "AB890X", + "43006": "AB890X", + "43007": "AB890X", + "43008": "AB890X", + "43009": "AB890X", + "43010": "AB890X", + "43011": "AB890X", + "43013": "AB890X", + "43014": "AB890X", + "43015": "AB890X", + "43016": "AB890X", + "43017": "AB890X", + "43018": "AB890X", + "43019": "AB890X", + "43021": "AB890X", + "43022": "AB890X", + "43023": "AB890X", + "43025": "AB890X", + "43026": "AB890X", + "43027": "AB890X", + "43028": "AB890X", + "43029": "AB890X", + "43030": "AB890X", + "43031": "AB890X", + "43032": "AB890X", + "43033": "AB890X", + "43035": "AB890X", + "43036": "AB890X", + "43037": "AB890X", + "43040": "AB890X", + "43041": "AB890X", + "43044": "AB890X", + "43045": "AB890X", + "43046": "AB890X", + "43047": "AB890X", + "43048": "AB890X", + "43050": "AB890X", + "43054": "AB890X", + "43055": "AB890X", + "43056": "AB890X", + "43058": "AB889X", + "43060": "AB890X", + "43061": "AB890X", + "43062": "AB890X", + "43064": "AB890X", + "43065": "AB890X", + "43066": "AB890X", + "43067": "AB890X", + "43068": "AB890X", + "43070": "AB890X", + "43071": "AB890X", + "43072": "AB890X", + "43073": "AB890X", + "43074": "AB890X", + "43076": "AB890X", + "43077": "AB890X", + "43078": "AB890X", + "43080": "AB890X", + "43081": "AB890X", + "43082": "AB890X", + "43083": "AB890X", + "43084": "AB890X", + "43085": "AB890X", + "43086": "AB890X", + "43093": "AB890X", + "43098": "AB890X", + "43101": "AB890X", + "43102": "AB890X", + "43103": "AB890X", + "43105": "AB890X", + "43106": "AB890X", + "43107": "AB890X", + "43109": "AB890X", + "43110": "AB890X", + "43111": "AB890X", + "43112": "AB890X", + "43113": "AB890X", + "43115": "AB890X", + "43116": "AB890X", + "43117": "AB890X", + "43119": "AB890X", + "43123": "AB890X", + "43125": "AB890X", + "43126": "AB890X", + "43127": "AB890X", + "43128": "AB890X", + "43130": "AB890X", + "43135": "AB890X", + "43136": "AB890X", + "43137": "AB890X", + "43138": "AB890X", + "43140": "AB890X", + "43142": "AB890X", + "43143": "AB890X", + "43144": "AB890X", + "43145": "AB890X", + "43146": "AB890X", + "43147": "AB890X", + "43148": "AB890X", + "43149": "AB890X", + "43150": "AB890X", + "43151": "AB890X", + "43152": "AB890X", + "43153": "AB890X", + "43154": "AB890X", + "43155": "AB890X", + "43156": "AB890X", + "43157": "AB890X", + "43158": "AB890X", + "43160": "AB890X", + "43162": "AB890X", + "43163": "AB890X", + "43164": "AB890X", + "43195": "AB890X", + "43196": "AB890X", + "43198": "AB890X", + "43199": "AB890X", + "43201": "AB890X", + "43202": "AB890X", + "43203": "AB890X", + "43204": "AB890X", + "43205": "AB890X", + "43206": "AB890X", + "43207": "AB890X", + "43209": "AB890X", + "43210": "AB890X", + "43211": "AB890X", + "43212": "AB890X", + "43213": "AB890X", + "43214": "AB890X", + "43215": "AB890X", + "43216": "AB890X", + "43217": "AB890X", + "43218": "AB890X", + "43219": "AB890X", + "43220": "AB890X", + "43221": "AB890X", + "43222": "AB890X", + "43223": "AB890X", + "43224": "AB890X", + "43226": "AB890X", + "43227": "AB890X", + "43228": "AB890X", + "43229": "AB890X", + "43230": "AB890X", + "43231": "AB890X", + "43232": "AB890X", + "43234": "AB890X", + "43235": "AB890X", + "43236": "AB890X", + "43240": "AB890X", + "43251": "AB890X", + "43260": "AB890X", + "43265": "AB890X", + "43266": "AB890X", + "43268": "AB890X", + "43270": "AB890X", + "43271": "AB890X", + "43272": "AB890X", + "43279": "AB890X", + "43287": "AB890X", + "43291": "AB890X", + "43299": "AB890X", + "43301": "AB890X", + "43302": "AB890X", + "43306": "AB890X", + "43307": "AB890X", + "43310": "AB890X", + "43311": "AB890X", + "43314": "AB890X", + "43315": "AB890X", + "43316": "AB890X", + "43317": "AB890X", + "43318": "AB890X", + "43319": "AB890X", + "43320": "AB890X", + "43321": "AB890X", + "43322": "AB890X", + "43323": "AB890X", + "43324": "AB890X", + "43325": "AB890X", + "43326": "AB890X", + "43330": "AB890X", + "43331": "AB890X", + "43332": "AB890X", + "43333": "AB890X", + "43334": "AB890X", + "43335": "AB890X", + "43336": "AB890X", + "43337": "AB890X", + "43338": "AB890X", + "43340": "AB890X", + "43341": "AB890X", + "43342": "AB890X", + "43343": "AB890X", + "43344": "AB890X", + "43345": "AB890X", + "43346": "AB890X", + "43347": "AB890X", + "43348": "AB890X", + "43349": "AB890X", + "43350": "AB890X", + "43351": "AB890X", + "43356": "AB890X", + "43357": "AB890X", + "43358": "AB890X", + "43359": "AB890X", + "43360": "AB890X", + "43402": "AB890X", + "43403": "AB890X", + "43406": "AB890X", + "43407": "AB890X", + "43408": "AB890X", + "43410": "AB890X", + "43412": "AB890X", + "43413": "AB890X", + "43414": "AB890X", + "43416": "AB890X", + "43420": "AB890X", + "43430": "AB890X", + "43431": "AB890X", + "43432": "AB890X", + "43433": "AB890X", + "43434": "AB890X", + "43435": "AB890X", + "43436": "AB890X", + "43437": "AB890X", + "43438": "AB890X", + "43439": "AB890X", + "43440": "AB890X", + "43441": "AB890X", + "43442": "AB890X", + "43443": "AB890X", + "43445": "AB890X", + "43446": "AB890X", + "43447": "AB890X", + "43449": "AB890X", + "43450": "AB890X", + "43451": "AB890X", + "43452": "AB890X", + "43456": "AB890X", + "43457": "AB890X", + "43458": "AB890X", + "43460": "AB890X", + "43462": "AB890X", + "43463": "AB890X", + "43464": "AB890X", + "43465": "AB890X", + "43466": "AB890X", + "43467": "AB890X", + "43468": "AB890X", + "43469": "AB890X", + "43501": "AB890X", + "43502": "AB890X", + "43504": "AB890X", + "43505": "AB890X", + "43506": "AB890X", + "43510": "AB890X", + "43511": "AB890X", + "43512": "AB890X", + "43515": "AB890X", + "43516": "AB890X", + "43517": "AB890X", + "43518": "AB890X", + "43519": "AB890X", + "43520": "AB890X", + "43521": "AB890X", + "43522": "AB890X", + "43523": "AB890X", + "43524": "AB890X", + "43525": "AB890X", + "43526": "AB890X", + "43527": "AB890X", + "43528": "AB890X", + "43529": "AB890X", + "43530": "AB890X", + "43531": "AB890X", + "43532": "AB890X", + "43533": "AB890X", + "43534": "AB890X", + "43535": "AB890X", + "43536": "AB890X", + "43537": "AB890X", + "43540": "AB890X", + "43541": "AB890X", + "43542": "AB890X", + "43543": "AB890X", + "43545": "AB890X", + "43547": "AB890X", + "43548": "AB890X", + "43549": "AB890X", + "43550": "AB890X", + "43551": "AB890X", + "43552": "AB890X", + "43553": "AB890X", + "43554": "AB890X", + "43555": "AB890X", + "43556": "AB890X", + "43557": "AB890X", + "43558": "AB890X", + "43560": "AB890X", + "43565": "AB890X", + "43566": "AB890X", + "43567": "AB890X", + "43569": "AB890X", + "43570": "AB890X", + "43571": "AB890X", + "43601": "AB890X", + "43603": "AB890X", + "43604": "AB890X", + "43605": "AB889X", + "43606": "AB890X", + "43607": "AB890X", + "43608": "AB890X", + "43609": "AB890X", + "43610": "AB890X", + "43611": "AB890X", + "43612": "AB889X", + "43613": "AB890X", + "43614": "AB890X", + "43615": "AB890X", + "43616": "AB890X", + "43617": "AB890X", + "43618": "AB890X", + "43619": "AB890X", + "43620": "AB890X", + "43623": "AB890X", + "43635": "AB890X", + "43652": "AB890X", + "43654": "AB890X", + "43656": "AB890X", + "43657": "AB890X", + "43659": "AB890X", + "43660": "AB890X", + "43661": "AB890X", + "43666": "AB890X", + "43667": "AB890X", + "43681": "AB890X", + "43682": "AB890X", + "43697": "AB890X", + "43699": "AB890X", + "43701": "AB890X", + "43702": "AB890X", + "43710": "AB900X", + "43711": "AB900X", + "43713": "AB900X", + "43716": "AB900X", + "43717": "AB900X", + "43718": "AB900X", + "43719": "AB900X", + "43720": "AB890X", + "43721": "AB890X", + "43722": "AB890X", + "43723": "AB890X", + "43724": "AB900X", + "43725": "AB890X", + "43727": "AB890X", + "43728": "AB900X", + "43730": "AB890X", + "43731": "AB890X", + "43732": "AB890X", + "43733": "AB890X", + "43734": "AB890X", + "43735": "AB890X", + "43736": "AB900X", + "43738": "AB890X", + "43739": "AB890X", + "43740": "AB890X", + "43746": "AB890X", + "43747": "AB900X", + "43748": "AB890X", + "43749": "AB890X", + "43750": "AB890X", + "43752": "AB900X", + "43754": "AB900X", + "43755": "AB890X", + "43756": "AB900X", + "43757": "AB900X", + "43758": "AB900X", + "43759": "AB900X", + "43760": "AB890X", + "43761": "AB890X", + "43762": "AB890X", + "43764": "AB890X", + "43766": "AB890X", + "43767": "AB890X", + "43768": "AB890X", + "43771": "AB890X", + "43772": "AB890X", + "43773": "AB890X", + "43777": "AB890X", + "43778": "AB890X", + "43779": "AB900X", + "43780": "AB890X", + "43782": "AB890X", + "43783": "AB890X", + "43786": "AB900X", + "43787": "AB900X", + "43788": "AB900X", + "43789": "AB900X", + "43791": "AB890X", + "43793": "AB900X", + "43802": "AB890X", + "43803": "AB890X", + "43804": "AB890X", + "43805": "AB890X", + "43811": "AB890X", + "43812": "AB890X", + "43821": "AB890X", + "43822": "AB890X", + "43824": "AB890X", + "43828": "AB890X", + "43830": "AB890X", + "43832": "AB890X", + "43836": "AB890X", + "43837": "AB890X", + "43840": "AB890X", + "43842": "AB890X", + "43843": "AB890X", + "43844": "AB890X", + "43845": "AB890X", + "43901": "AB900X", + "43902": "AB900X", + "43903": "AB900X", + "43905": "AB900X", + "43906": "AB900X", + "43907": "AB900X", + "43908": "AB900X", + "43909": "AB900X", + "43910": "AB900X", + "43912": "AB900X", + "43913": "AB900X", + "43914": "AB900X", + "43915": "AB900X", + "43916": "AB900X", + "43917": "AB900X", + "43920": "AB900X", + "43925": "AB900X", + "43926": "AB900X", + "43927": "AB900X", + "43928": "AB900X", + "43930": "AB900X", + "43931": "AB900X", + "43932": "AB900X", + "43933": "AB900X", + "43934": "AB900X", + "43935": "AB900X", + "43937": "AB900X", + "43938": "AB900X", + "43939": "AB900X", + "43940": "AB900X", + "43941": "AB900X", + "43942": "AB900X", + "43943": "AB900X", + "43944": "AB900X", + "43945": "AB890X", + "43946": "AB900X", + "43947": "AB900X", + "43948": "AB900X", + "43950": "AB900X", + "43951": "AB900X", + "43952": "AB900X", + "43953": "AB900X", + "43961": "AB900X", + "43962": "AB890X", + "43963": "AB900X", + "43964": "AB900X", + "43967": "AB900X", + "43968": "AB900X", + "43970": "AB900X", + "43971": "AB900X", + "43972": "AB900X", + "43973": "AB890X", + "43974": "AB900X", + "43976": "AB900X", + "43977": "AB900X", + "43981": "AB900X", + "43983": "AB900X", + "43984": "AB900X", + "43985": "AB900X", + "43986": "AB900X", + "43988": "AB900X", + "44001": "AB890X", + "44003": "AB890X", + "44004": "AB890X", + "44005": "AB890X", + "44010": "AB890X", + "44011": "AB890X", + "44012": "AB890X", + "44017": "AB890X", + "44021": "AB890X", + "44022": "AB890X", + "44023": "AB890X", + "44024": "AB890X", + "44026": "AB890X", + "44028": "AB890X", + "44030": "AB890X", + "44032": "AB890X", + "44033": "AB890X", + "44035": "AB890X", + "44036": "AB890X", + "44039": "AB890X", + "44040": "AB890X", + "44041": "AB890X", + "44044": "AB890X", + "44045": "AB890X", + "44046": "AB890X", + "44047": "AB890X", + "44048": "AB890X", + "44049": "AB890X", + "44050": "AB890X", + "44052": "AB890X", + "44053": "AB890X", + "44054": "AB890X", + "44055": "AB890X", + "44056": "AB890X", + "44057": "AB890X", + "44060": "AB890X", + "44061": "AB890X", + "44062": "AB890X", + "44064": "AB890X", + "44065": "AB890X", + "44067": "AB890X", + "44068": "AB890X", + "44070": "AB890X", + "44072": "AB890X", + "44073": "AB890X", + "44074": "AB890X", + "44076": "AB890X", + "44077": "AB890X", + "44080": "AB890X", + "44081": "AB890X", + "44082": "AB890X", + "44084": "AB890X", + "44085": "AB890X", + "44086": "AB890X", + "44087": "AB890X", + "44088": "AB890X", + "44089": "AB890X", + "44090": "AB890X", + "44092": "AB890X", + "44093": "AB890X", + "44094": "AB890X", + "44095": "AB890X", + "44096": "AB890X", + "44097": "AB890X", + "44099": "AB890X", + "44101": "AB890X", + "44102": "AB890X", + "44103": "AB890X", + "44104": "AB890X", + "44105": "AB890X", + "44106": "AB890X", + "44107": "AB890X", + "44108": "AB890X", + "44109": "AB890X", + "44110": "AB890X", + "44111": "AB890X", + "44112": "AB890X", + "44113": "AB890X", + "44114": "AB890X", + "44115": "AB890X", + "44116": "AB890X", + "44117": "AB890X", + "44118": "AB890X", + "44119": "AB890X", + "44120": "AB890X", + "44121": "AB890X", + "44122": "AB890X", + "44123": "AB890X", + "44124": "AB890X", + "44125": "AB890X", + "44126": "AB890X", + "44127": "AB890X", + "44128": "AB890X", + "44129": "AB890X", + "44130": "AB890X", + "44131": "AB890X", + "44132": "AB890X", + "44133": "AB890X", + "44134": "AB890X", + "44135": "AB890X", + "44136": "AB890X", + "44137": "AB890X", + "44138": "AB890X", + "44139": "AB890X", + "44140": "AB890X", + "44141": "AB890X", + "44142": "AB890X", + "44143": "AB889X", + "44144": "AB890X", + "44145": "AB890X", + "44146": "AB890X", + "44147": "AB890X", + "44149": "AB890X", + "44178": "AB890X", + "44181": "AB890X", + "44185": "AB890X", + "44188": "AB890X", + "44189": "AB890X", + "44190": "AB890X", + "44191": "AB890X", + "44192": "AB890X", + "44193": "AB890X", + "44194": "AB890X", + "44195": "AB890X", + "44197": "AB890X", + "44198": "AB890X", + "44199": "AB890X", + "44201": "AB890X", + "44202": "AB890X", + "44203": "AB890X", + "44210": "AB890X", + "44211": "AB890X", + "44212": "AB890X", + "44214": "AB890X", + "44215": "AB890X", + "44216": "AB890X", + "44217": "AB890X", + "44221": "AB890X", + "44222": "AB890X", + "44223": "AB890X", + "44224": "AB890X", + "44230": "AB890X", + "44231": "AB890X", + "44232": "AB890X", + "44233": "AB890X", + "44234": "AB890X", + "44235": "AB890X", + "44236": "AB890X", + "44237": "AB890X", + "44240": "AB890X", + "44241": "AB890X", + "44242": "AB890X", + "44243": "AB890X", + "44250": "AB890X", + "44251": "AB890X", + "44253": "AB890X", + "44254": "AB890X", + "44255": "AB890X", + "44256": "AB890X", + "44258": "AB890X", + "44260": "AB890X", + "44262": "AB890X", + "44264": "AB890X", + "44265": "AB890X", + "44266": "AB890X", + "44270": "AB890X", + "44272": "AB890X", + "44273": "AB890X", + "44274": "AB890X", + "44275": "AB890X", + "44276": "AB890X", + "44278": "AB890X", + "44280": "AB890X", + "44281": "AB890X", + "44282": "AB890X", + "44285": "AB890X", + "44286": "AB890X", + "44287": "AB890X", + "44288": "AB890X", + "44301": "AB890X", + "44302": "AB890X", + "44303": "AB890X", + "44304": "AB890X", + "44305": "AB890X", + "44306": "AB890X", + "44307": "AB890X", + "44308": "AB890X", + "44309": "AB890X", + "44310": "AB890X", + "44311": "AB890X", + "44312": "AB890X", + "44313": "AB890X", + "44314": "AB890X", + "44315": "AB890X", + "44316": "AB890X", + "44317": "AB890X", + "44319": "AB890X", + "44320": "AB890X", + "44321": "AB890X", + "44322": "AB890X", + "44325": "AB890X", + "44326": "AB890X", + "44328": "AB890X", + "44333": "AB890X", + "44334": "AB890X", + "44372": "AB890X", + "44393": "AB890X", + "44396": "AB890X", + "44398": "AB890X", + "44399": "AB890X", + "44401": "AB900X", + "44402": "AB900X", + "44403": "AB900X", + "44404": "AB900X", + "44405": "AB900X", + "44406": "AB900X", + "44408": "AB890X", + "44410": "AB900X", + "44411": "AB890X", + "44412": "AB890X", + "44413": "AB890X", + "44415": "AB890X", + "44416": "AB900X", + "44417": "AB900X", + "44418": "AB900X", + "44420": "AB900X", + "44422": "AB900X", + "44423": "AB890X", + "44424": "AB900X", + "44425": "AB900X", + "44427": "AB889X", + "44428": "AB900X", + "44429": "AB900X", + "44430": "AB900X", + "44431": "AB890X", + "44432": "AB890X", + "44436": "AB900X", + "44437": "AB900X", + "44438": "AB900X", + "44439": "AB900X", + "44440": "AB900X", + "44441": "AB890X", + "44442": "AB900X", + "44443": "AB900X", + "44444": "AB900X", + "44445": "AB890X", + "44446": "AB900X", + "44449": "AB890X", + "44450": "AB900X", + "44451": "AB900X", + "44452": "AB900X", + "44453": "AB900X", + "44454": "AB900X", + "44455": "AB890X", + "44460": "AB900X", + "44470": "AB900X", + "44471": "AB900X", + "44473": "AB900X", + "44481": "AB900X", + "44482": "AB900X", + "44483": "AB900X", + "44484": "AB900X", + "44485": "AB900X", + "44486": "AB900X", + "44488": "AB900X", + "44490": "AB890X", + "44491": "AB900X", + "44492": "AB890X", + "44493": "AB890X", + "44501": "AB900X", + "44502": "AB900X", + "44503": "AB900X", + "44504": "AB900X", + "44505": "AB900X", + "44506": "AB900X", + "44507": "AB900X", + "44509": "AB900X", + "44510": "AB900X", + "44511": "AB900X", + "44512": "AB900X", + "44513": "AB900X", + "44514": "AB900X", + "44515": "AB900X", + "44555": "AB900X", + "44601": "AB890X", + "44606": "AB890X", + "44607": "AB890X", + "44608": "AB890X", + "44609": "AB900X", + "44610": "AB890X", + "44611": "AB890X", + "44612": "AB890X", + "44613": "AB890X", + "44614": "AB890X", + "44615": "AB890X", + "44617": "AB890X", + "44618": "AB890X", + "44619": "AB900X", + "44620": "AB890X", + "44621": "AB890X", + "44622": "AB890X", + "44624": "AB890X", + "44625": "AB890X", + "44626": "AB890X", + "44627": "AB890X", + "44628": "AB890X", + "44629": "AB890X", + "44630": "AB890X", + "44631": "AB890X", + "44632": "AB890X", + "44633": "AB890X", + "44634": "AB890X", + "44636": "AB890X", + "44637": "AB890X", + "44638": "AB890X", + "44639": "AB890X", + "44640": "AB890X", + "44641": "AB890X", + "44643": "AB890X", + "44644": "AB890X", + "44645": "AB890X", + "44646": "AB890X", + "44647": "AB890X", + "44648": "AB890X", + "44650": "AB890X", + "44651": "AB890X", + "44652": "AB890X", + "44653": "AB890X", + "44654": "AB890X", + "44656": "AB890X", + "44657": "AB890X", + "44659": "AB890X", + "44660": "AB890X", + "44661": "AB890X", + "44662": "AB890X", + "44663": "AB890X", + "44665": "AB890X", + "44666": "AB890X", + "44667": "AB890X", + "44669": "AB890X", + "44670": "AB890X", + "44671": "AB890X", + "44672": "AB900X", + "44675": "AB890X", + "44676": "AB890X", + "44677": "AB890X", + "44678": "AB890X", + "44679": "AB890X", + "44680": "AB890X", + "44681": "AB890X", + "44682": "AB890X", + "44683": "AB890X", + "44685": "AB890X", + "44687": "AB890X", + "44688": "AB890X", + "44689": "AB890X", + "44690": "AB890X", + "44691": "AB890X", + "44693": "AB900X", + "44695": "AB900X", + "44697": "AB890X", + "44699": "AB900X", + "44701": "AB890X", + "44702": "AB890X", + "44703": "AB890X", + "44704": "AB890X", + "44705": "AB890X", + "44706": "AB890X", + "44707": "AB890X", + "44708": "AB890X", + "44709": "AB890X", + "44710": "AB890X", + "44711": "AB890X", + "44712": "AB890X", + "44714": "AB890X", + "44718": "AB890X", + "44720": "AB890X", + "44721": "AB890X", + "44730": "AB890X", + "44735": "AB890X", + "44750": "AB890X", + "44767": "AB890X", + "44799": "AB890X", + "44802": "AB890X", + "44804": "AB890X", + "44805": "AB890X", + "44807": "AB890X", + "44809": "AB890X", + "44811": "AB890X", + "44813": "AB890X", + "44814": "AB890X", + "44815": "AB890X", + "44816": "AB890X", + "44817": "AB890X", + "44818": "AB890X", + "44820": "AB890X", + "44822": "AB890X", + "44824": "AB890X", + "44825": "AB890X", + "44826": "AB890X", + "44827": "AB890X", + "44828": "AB890X", + "44830": "AB890X", + "44833": "AB890X", + "44836": "AB890X", + "44837": "AB890X", + "44838": "AB890X", + "44839": "AB890X", + "44840": "AB890X", + "44841": "AB890X", + "44842": "AB890X", + "44843": "AB890X", + "44844": "AB890X", + "44845": "AB890X", + "44846": "AB890X", + "44847": "AB890X", + "44848": "AB890X", + "44849": "AB890X", + "44850": "AB890X", + "44851": "AB890X", + "44853": "AB890X", + "44854": "AB890X", + "44855": "AB890X", + "44856": "AB890X", + "44857": "AB890X", + "44859": "AB890X", + "44860": "AB890X", + "44861": "AB890X", + "44862": "AB890X", + "44864": "AB890X", + "44865": "AB890X", + "44866": "AB890X", + "44867": "AB890X", + "44870": "AB890X", + "44871": "AB890X", + "44874": "AB890X", + "44875": "AB890X", + "44878": "AB890X", + "44880": "AB890X", + "44881": "AB890X", + "44882": "AB890X", + "44883": "AB890X", + "44887": "AB890X", + "44888": "AB890X", + "44889": "AB890X", + "44890": "AB890X", + "44901": "AB890X", + "44902": "AB890X", + "44903": "AB890X", + "44904": "AB890X", + "44905": "AB890X", + "44906": "AB890X", + "44907": "AB890X", + "44999": "AB890X", + "45001": "AB890X", + "45002": "AB890X", + "45003": "AB890X", + "45004": "AB890X", + "45005": "AB890X", + "45011": "AB890X", + "45012": "AB890X", + "45013": "AB890X", + "45014": "AB890X", + "45015": "AB890X", + "45018": "AB890X", + "45025": "AB890X", + "45026": "AB890X", + "45030": "AB890X", + "45032": "AB890X", + "45033": "AB890X", + "45034": "AB890X", + "45036": "AB890X", + "45039": "AB890X", + "45040": "AB890X", + "45041": "AB890X", + "45042": "AB888X", + "45043": "AB890X", + "45044": "AB890X", + "45047": "AB890X", + "45050": "AB890X", + "45051": "AB890X", + "45052": "AB890X", + "45053": "AB890X", + "45054": "AB890X", + "45055": "AB890X", + "45056": "AB890X", + "45061": "AB890X", + "45062": "AB890X", + "45063": "AB890X", + "45064": "AB890X", + "45065": "AB890X", + "45066": "AB890X", + "45067": "AB890X", + "45068": "AB890X", + "45069": "AB890X", + "45070": "AB890X", + "45071": "AB890X", + "45101": "AB890X", + "45102": "AB890X", + "45103": "AB890X", + "45105": "AB890X", + "45106": "AB890X", + "45107": "AB890X", + "45110": "AB890X", + "45111": "AB890X", + "45112": "AB890X", + "45113": "AB890X", + "45114": "AB890X", + "45115": "AB890X", + "45118": "AB890X", + "45119": "AB890X", + "45120": "AB890X", + "45121": "AB890X", + "45122": "AB890X", + "45123": "AB890X", + "45130": "AB890X", + "45131": "AB890X", + "45132": "AB890X", + "45133": "AB890X", + "45135": "AB890X", + "45138": "AB890X", + "45140": "AB890X", + "45142": "AB890X", + "45144": "AB890X", + "45145": "AB890X", + "45146": "AB890X", + "45147": "AB890X", + "45148": "AB890X", + "45150": "AB890X", + "45152": "AB890X", + "45153": "AB890X", + "45154": "AB890X", + "45155": "AB890X", + "45156": "AB890X", + "45157": "AB890X", + "45158": "AB890X", + "45159": "AB890X", + "45160": "AB890X", + "45162": "AB890X", + "45164": "AB890X", + "45166": "AB890X", + "45167": "AB890X", + "45168": "AB890X", + "45169": "AB890X", + "45171": "AB890X", + "45172": "AB890X", + "45174": "AB890X", + "45176": "AB890X", + "45177": "AB890X", + "45201": "AB890X", + "45202": "AB890X", + "45203": "AB890X", + "45204": "AB890X", + "45205": "AB890X", + "45206": "AB890X", + "45207": "AB890X", + "45208": "AB890X", + "45209": "AB890X", + "45211": "AB890X", + "45212": "AB890X", + "45213": "AB890X", + "45214": "AB890X", + "45215": "AB890X", + "45216": "AB890X", + "45217": "AB890X", + "45218": "AB890X", + "45219": "AB890X", + "45220": "AB890X", + "45221": "AB890X", + "45222": "AB890X", + "45223": "AB890X", + "45224": "AB890X", + "45225": "AB890X", + "45226": "AB890X", + "45227": "AB890X", + "45228": "AB890X", + "45229": "AB890X", + "45230": "AB890X", + "45231": "AB890X", + "45232": "AB890X", + "45233": "AB890X", + "45234": "AB890X", + "45235": "AB890X", + "45236": "AB890X", + "45237": "AB890X", + "45238": "AB890X", + "45239": "AB890X", + "45240": "AB890X", + "45241": "AB890X", + "45242": "AB890X", + "45243": "AB890X", + "45244": "AB890X", + "45245": "AB890X", + "45246": "AB890X", + "45247": "AB890X", + "45248": "AB890X", + "45249": "AB890X", + "45250": "AB890X", + "45251": "AB890X", + "45252": "AB890X", + "45253": "AB890X", + "45254": "AB890X", + "45255": "AB890X", + "45258": "AB890X", + "45262": "AB890X", + "45263": "AB890X", + "45264": "AB890X", + "45267": "AB890X", + "45268": "AB890X", + "45269": "AB890X", + "45270": "AB890X", + "45271": "AB890X", + "45273": "AB890X", + "45274": "AB890X", + "45275": "AB890X", + "45277": "AB890X", + "45280": "AB890X", + "45296": "AB890X", + "45298": "AB890X", + "45299": "AB890X", + "45301": "AB890X", + "45302": "AB890X", + "45303": "AB890X", + "45304": "AB890X", + "45305": "AB890X", + "45306": "AB890X", + "45307": "AB890X", + "45308": "AB890X", + "45309": "AB890X", + "45310": "AB890X", + "45311": "AB890X", + "45312": "AB890X", + "45314": "AB890X", + "45315": "AB890X", + "45316": "AB890X", + "45317": "AB890X", + "45318": "AB890X", + "45319": "AB890X", + "45320": "AB890X", + "45321": "AB890X", + "45322": "AB890X", + "45323": "AB890X", + "45324": "AB890X", + "45325": "AB890X", + "45326": "AB890X", + "45327": "AB890X", + "45328": "AB890X", + "45330": "AB890X", + "45331": "AB890X", + "45332": "AB890X", + "45333": "AB890X", + "45334": "AB890X", + "45335": "AB890X", + "45336": "AB890X", + "45337": "AB890X", + "45338": "AB890X", + "45339": "AB890X", + "45340": "AB890X", + "45341": "AB890X", + "45342": "AB890X", + "45343": "AB890X", + "45344": "AB890X", + "45345": "AB890X", + "45346": "AB890X", + "45347": "AB890X", + "45348": "AB890X", + "45349": "AB890X", + "45350": "AB890X", + "45351": "AB890X", + "45352": "AB890X", + "45353": "AB890X", + "45354": "AB890X", + "45356": "AB890X", + "45358": "AB890X", + "45359": "AB890X", + "45360": "AB890X", + "45361": "AB890X", + "45362": "AB890X", + "45363": "AB890X", + "45365": "AB890X", + "45367": "AB890X", + "45368": "AB890X", + "45369": "AB890X", + "45370": "AB890X", + "45371": "AB890X", + "45372": "AB890X", + "45373": "AB890X", + "45374": "AB890X", + "45377": "AB890X", + "45378": "AB890X", + "45380": "AB890X", + "45381": "AB890X", + "45382": "AB890X", + "45383": "AB890X", + "45384": "AB890X", + "45385": "AB890X", + "45387": "AB890X", + "45388": "AB890X", + "45389": "AB890X", + "45390": "AB888X", + "45401": "AB890X", + "45402": "AB890X", + "45403": "AB890X", + "45404": "AB890X", + "45405": "AB890X", + "45406": "AB890X", + "45408": "AB890X", + "45409": "AB890X", + "45410": "AB890X", + "45412": "AB890X", + "45413": "AB890X", + "45414": "AB890X", + "45415": "AB890X", + "45416": "AB890X", + "45417": "AB890X", + "45418": "AB890X", + "45419": "AB890X", + "45420": "AB890X", + "45422": "AB890X", + "45423": "AB890X", + "45424": "AB890X", + "45426": "AB890X", + "45427": "AB890X", + "45428": "AB890X", + "45429": "AB890X", + "45430": "AB890X", + "45431": "AB890X", + "45432": "AB890X", + "45433": "AB890X", + "45434": "AB890X", + "45435": "AB890X", + "45437": "AB890X", + "45439": "AB890X", + "45440": "AB900X", + "45441": "AB890X", + "45448": "AB890X", + "45449": "AB890X", + "45454": "AB890X", + "45458": "AB890X", + "45459": "AB890X", + "45463": "AB890X", + "45469": "AB890X", + "45470": "AB890X", + "45475": "AB890X", + "45479": "AB890X", + "45481": "AB890X", + "45482": "AB890X", + "45490": "AB890X", + "45501": "AB890X", + "45502": "AB890X", + "45503": "AB890X", + "45504": "AB890X", + "45505": "AB890X", + "45506": "AB890X", + "45600": "AB890X", + "45601": "AB890X", + "45612": "AB890X", + "45613": "AB890X", + "45614": "AB900X", + "45616": "AB890X", + "45617": "AB890X", + "45618": "AB890X", + "45619": "AB900X", + "45620": "AB900X", + "45621": "AB900X", + "45622": "AB890X", + "45623": "AB900X", + "45624": "AB890X", + "45628": "AB890X", + "45629": "AB900X", + "45630": "AB900X", + "45631": "AB900X", + "45633": "AB890X", + "45634": "AB890X", + "45636": "AB900X", + "45638": "AB900X", + "45640": "AB900X", + "45642": "AB890X", + "45643": "AB900X", + "45644": "AB890X", + "45645": "AB900X", + "45646": "AB890X", + "45647": "AB890X", + "45648": "AB900X", + "45650": "AB890X", + "45651": "AB900X", + "45652": "AB900X", + "45653": "AB900X", + "45654": "AB890X", + "45656": "AB900X", + "45657": "AB900X", + "45658": "AB900X", + "45659": "AB900X", + "45660": "AB890X", + "45661": "AB890X", + "45662": "AB900X", + "45663": "AB900X", + "45669": "AB900X", + "45671": "AB900X", + "45672": "AB900X", + "45673": "AB900X", + "45674": "AB900X", + "45675": "AB900X", + "45677": "AB900X", + "45678": "AB900X", + "45679": "AB890X", + "45680": "AB900X", + "45681": "AB890X", + "45682": "AB900X", + "45683": "AB900X", + "45684": "AB890X", + "45685": "AB900X", + "45686": "AB900X", + "45687": "AB890X", + "45688": "AB900X", + "45690": "AB890X", + "45692": "AB900X", + "45693": "AB890X", + "45694": "AB900X", + "45695": "AB890X", + "45696": "AB900X", + "45697": "AB890X", + "45698": "AB890X", + "45699": "AB900X", + "45701": "AB890X", + "45710": "AB890X", + "45711": "AB890X", + "45712": "AB900X", + "45713": "AB900X", + "45714": "AB900X", + "45715": "AB900X", + "45716": "AB890X", + "45717": "AB890X", + "45719": "AB890X", + "45720": "AB900X", + "45721": "AB900X", + "45723": "AB890X", + "45724": "AB900X", + "45727": "AB900X", + "45729": "AB900X", + "45732": "AB890X", + "45734": "AB900X", + "45735": "AB890X", + "45739": "AB890X", + "45740": "AB890X", + "45741": "AB900X", + "45742": "AB900X", + "45743": "AB900X", + "45744": "AB900X", + "45745": "AB900X", + "45746": "AB900X", + "45750": "AB900X", + "45760": "AB900X", + "45761": "AB890X", + "45764": "AB890X", + "45766": "AB890X", + "45767": "AB900X", + "45768": "AB900X", + "45769": "AB900X", + "45770": "AB900X", + "45771": "AB890X", + "45772": "AB900X", + "45773": "AB900X", + "45775": "AB900X", + "45776": "AB890X", + "45777": "AB890X", + "45778": "AB890X", + "45779": "AB900X", + "45780": "AB890X", + "45782": "AB890X", + "45783": "AB900X", + "45784": "AB900X", + "45786": "AB900X", + "45787": "AB900X", + "45788": "AB900X", + "45789": "AB900X", + "45801": "AB890X", + "45802": "AB890X", + "45804": "AB890X", + "45805": "AB890X", + "45806": "AB890X", + "45807": "AB888X", + "45808": "AB890X", + "45809": "AB890X", + "45810": "AB890X", + "45812": "AB890X", + "45813": "AB890X", + "45814": "AB890X", + "45815": "AB890X", + "45816": "AB890X", + "45817": "AB890X", + "45819": "AB890X", + "45820": "AB890X", + "45821": "AB890X", + "45822": "AB890X", + "45826": "AB890X", + "45827": "AB890X", + "45828": "AB890X", + "45830": "AB890X", + "45831": "AB890X", + "45832": "AB888X", + "45833": "AB888X", + "45835": "AB890X", + "45836": "AB890X", + "45837": "AB890X", + "45838": "AB888X", + "45839": "AB890X", + "45840": "AB890X", + "45841": "AB890X", + "45843": "AB890X", + "45844": "AB888X", + "45845": "AB890X", + "45846": "AB890X", + "45848": "AB890X", + "45849": "AB890X", + "45850": "AB890X", + "45851": "AB890X", + "45853": "AB890X", + "45854": "AB890X", + "45855": "AB890X", + "45856": "AB890X", + "45858": "AB890X", + "45859": "AB890X", + "45860": "AB890X", + "45861": "AB890X", + "45862": "AB890X", + "45863": "AB888X", + "45864": "AB890X", + "45865": "AB890X", + "45866": "AB890X", + "45867": "AB890X", + "45868": "AB890X", + "45869": "AB890X", + "45870": "AB890X", + "45871": "AB890X", + "45872": "AB890X", + "45873": "AB890X", + "45874": "AB888X", + "45875": "AB890X", + "45876": "AB890X", + "45877": "AB890X", + "45879": "AB890X", + "45880": "AB890X", + "45881": "AB890X", + "45882": "AB888X", + "45883": "AB890X", + "45884": "AB890X", + "45885": "AB890X", + "45886": "AB888X", + "45887": "AB888X", + "45888": "AB890X", + "45889": "AB890X", + "45890": "AB890X", + "45891": "AB888X", + "45893": "AB890X", + "45894": "AB888X", + "45895": "AB890X", + "45896": "AB890X", + "45897": "AB890X", + "45898": "AB888X", + "45899": "AB888X", + "45999": "AB890X", + "46001": "AB888X", + "46011": "AB888X", + "46012": "AB888X", + "46013": "AB888X", + "46014": "AB888X", + "46015": "AB888X", + "46016": "AB888X", + "46017": "AB888X", + "46018": "AB888X", + "46030": "AB888X", + "46031": "AB888X", + "46032": "AB888X", + "46033": "AB888X", + "46034": "AB888X", + "46035": "AB888X", + "46036": "AB888X", + "46037": "AB888X", + "46038": "AB888X", + "46039": "AB888X", + "46040": "AB888X", + "46041": "AB888X", + "46044": "AB888X", + "46045": "AB888X", + "46047": "AB888X", + "46048": "AB888X", + "46049": "AB888X", + "46050": "AB888X", + "46051": "AB888X", + "46052": "AB888X", + "46055": "AB888X", + "46056": "AB888X", + "46057": "AB888X", + "46058": "AB888X", + "46060": "AB888X", + "46061": "AB888X", + "46062": "AB888X", + "46063": "AB888X", + "46064": "AB888X", + "46065": "AB888X", + "46067": "AB888X", + "46068": "AB888X", + "46069": "AB888X", + "46070": "AB888X", + "46071": "AB888X", + "46072": "AB888X", + "46074": "AB888X", + "46075": "AB888X", + "46076": "AB888X", + "46077": "AB888X", + "46082": "AB888X", + "46102": "AB888X", + "46103": "AB888X", + "46104": "AB888X", + "46105": "AB888X", + "46106": "AB888X", + "46107": "AB888X", + "46110": "AB888X", + "46111": "AB888X", + "46112": "AB888X", + "46113": "AB888X", + "46115": "AB888X", + "46117": "AB888X", + "46118": "AB888X", + "46120": "AB888X", + "46121": "AB888X", + "46122": "AB888X", + "46123": "AB888X", + "46124": "AB888X", + "46125": "AB888X", + "46126": "AB888X", + "46127": "AB888X", + "46128": "AB888X", + "46129": "AB888X", + "46130": "AB888X", + "46131": "AB888X", + "46133": "AB888X", + "46135": "AB888X", + "46140": "AB888X", + "46142": "AB888X", + "46143": "AB888X", + "46144": "AB888X", + "46146": "AB888X", + "46147": "AB888X", + "46148": "AB888X", + "46149": "AB888X", + "46150": "AB888X", + "46151": "AB888X", + "46154": "AB888X", + "46155": "AB888X", + "46156": "AB888X", + "46157": "AB888X", + "46158": "AB888X", + "46160": "AB888X", + "46161": "AB888X", + "46162": "AB888X", + "46163": "AB888X", + "46164": "AB888X", + "46165": "AB888X", + "46166": "AB888X", + "46167": "AB888X", + "46168": "AB888X", + "46170": "AB888X", + "46171": "AB888X", + "46172": "AB888X", + "46173": "AB888X", + "46175": "AB888X", + "46176": "AB888X", + "46180": "AB888X", + "46181": "AB888X", + "46182": "AB888X", + "46183": "AB888X", + "46184": "AB888X", + "46186": "AB888X", + "46201": "AB888X", + "46202": "AB888X", + "46203": "AB888X", + "46204": "AB888X", + "46205": "AB888X", + "46206": "AB888X", + "46207": "AB888X", + "46208": "AB888X", + "46209": "AB888X", + "46211": "AB888X", + "46214": "AB888X", + "46216": "AB888X", + "46217": "AB888X", + "46218": "AB888X", + "46219": "AB888X", + "46220": "AB888X", + "46221": "AB888X", + "46222": "AB888X", + "46223": "AB888X", + "46224": "AB888X", + "46225": "AB888X", + "46226": "AB888X", + "46227": "AB888X", + "46228": "AB888X", + "46229": "AB888X", + "46230": "AB888X", + "46231": "AB888X", + "46234": "AB888X", + "46235": "AB888X", + "46236": "AB888X", + "46237": "AB888X", + "46239": "AB888X", + "46240": "AB888X", + "46241": "AB888X", + "46242": "AB888X", + "46244": "AB888X", + "46247": "AB888X", + "46249": "AB888X", + "46250": "AB888X", + "46251": "AB888X", + "46253": "AB888X", + "46254": "AB888X", + "46255": "AB888X", + "46256": "AB888X", + "46259": "AB888X", + "46260": "AB888X", + "46262": "AB888X", + "46266": "AB888X", + "46268": "AB888X", + "46274": "AB888X", + "46275": "AB888X", + "46277": "AB888X", + "46278": "AB888X", + "46280": "AB888X", + "46282": "AB888X", + "46283": "AB888X", + "46285": "AB888X", + "46290": "AB888X", + "46291": "AB888X", + "46295": "AB888X", + "46296": "AB888X", + "46298": "AB888X", + "46301": "AB887X", + "46302": "AB887X", + "46303": "AB887X", + "46304": "AB887X", + "46307": "AB887X", + "46308": "AB887X", + "46310": "AB887X", + "46311": "AB887X", + "46312": "AB887X", + "46319": "AB887X", + "46320": "AB887X", + "46321": "AB887X", + "46322": "AB887X", + "46323": "AB887X", + "46324": "AB887X", + "46325": "AB887X", + "46327": "AB887X", + "46340": "AB887X", + "46341": "AB887X", + "46342": "AB887X", + "46345": "AB887X", + "46346": "AB887X", + "46347": "AB887X", + "46348": "AB887X", + "46349": "AB888X", + "46350": "AB887X", + "46352": "AB887X", + "46355": "AB887X", + "46356": "AB887X", + "46360": "AB887X", + "46361": "AB887X", + "46365": "AB887X", + "46366": "AB887X", + "46368": "AB887X", + "46371": "AB887X", + "46372": "AB888X", + "46373": "AB887X", + "46374": "AB887X", + "46375": "AB887X", + "46376": "AB887X", + "46377": "AB887X", + "46379": "AB888X", + "46380": "AB887X", + "46381": "AB888X", + "46382": "AB887X", + "46383": "AB887X", + "46384": "AB887X", + "46385": "AB887X", + "46390": "AB887X", + "46391": "AB887X", + "46392": "AB887X", + "46393": "AB887X", + "46394": "AB887X", + "46401": "AB887X", + "46402": "AB887X", + "46403": "AB887X", + "46404": "AB887X", + "46405": "AB887X", + "46406": "AB887X", + "46407": "AB887X", + "46408": "AB887X", + "46409": "AB887X", + "46410": "AB887X", + "46411": "AB887X", + "46501": "AB887X", + "46502": "AB888X", + "46504": "AB887X", + "46506": "AB887X", + "46507": "AB887X", + "46508": "AB888X", + "46510": "AB888X", + "46511": "AB887X", + "46513": "AB887X", + "46514": "AB887X", + "46515": "AB887X", + "46516": "AB887X", + "46517": "AB887X", + "46524": "AB888X", + "46526": "AB887X", + "46527": "AB887X", + "46528": "AB887X", + "46530": "AB887X", + "46531": "AB887X", + "46532": "AB887X", + "46534": "AB887X", + "46536": "AB887X", + "46537": "AB887X", + "46538": "AB888X", + "46539": "AB888X", + "46540": "AB887X", + "46542": "AB888X", + "46543": "AB887X", + "46544": "AB887X", + "46545": "AB887X", + "46546": "AB887X", + "46550": "AB887X", + "46552": "AB887X", + "46553": "AB890X", + "46554": "AB887X", + "46555": "AB888X", + "46556": "AB887X", + "46561": "AB887X", + "46562": "AB888X", + "46563": "AB887X", + "46565": "AB888X", + "46567": "AB888X", + "46570": "AB887X", + "46571": "AB888X", + "46572": "AB887X", + "46573": "AB887X", + "46574": "AB887X", + "46580": "AB887X", + "46581": "AB888X", + "46582": "AB887X", + "46590": "AB888X", + "46595": "AB887X", + "46601": "AB887X", + "46604": "AB887X", + "46613": "AB887X", + "46614": "AB887X", + "46615": "AB887X", + "46616": "AB887X", + "46617": "AB887X", + "46619": "AB887X", + "46620": "AB887X", + "46624": "AB887X", + "46626": "AB887X", + "46628": "AB887X", + "46634": "AB887X", + "46635": "AB887X", + "46637": "AB887X", + "46660": "AB887X", + "46680": "AB887X", + "46699": "AB887X", + "46701": "AB888X", + "46702": "AB888X", + "46703": "AB888X", + "46704": "AB888X", + "46705": "AB888X", + "46706": "AB888X", + "46710": "AB888X", + "46711": "AB888X", + "46713": "AB888X", + "46714": "AB888X", + "46721": "AB888X", + "46723": "AB888X", + "46725": "AB888X", + "46730": "AB888X", + "46731": "AB888X", + "46732": "AB888X", + "46733": "AB888X", + "46737": "AB888X", + "46738": "AB888X", + "46740": "AB888X", + "46741": "AB888X", + "46742": "AB888X", + "46743": "AB888X", + "46745": "AB888X", + "46746": "AB889X", + "46747": "AB888X", + "46748": "AB888X", + "46750": "AB888X", + "46755": "AB888X", + "46759": "AB888X", + "46760": "AB888X", + "46761": "AB888X", + "46763": "AB888X", + "46764": "AB888X", + "46765": "AB888X", + "46766": "AB888X", + "46767": "AB888X", + "46769": "AB888X", + "46770": "AB888X", + "46771": "AB888X", + "46772": "AB888X", + "46773": "AB888X", + "46774": "AB888X", + "46776": "AB888X", + "46777": "AB888X", + "46778": "AB888X", + "46779": "AB888X", + "46780": "AB888X", + "46781": "AB888X", + "46782": "AB888X", + "46783": "AB888X", + "46784": "AB888X", + "46785": "AB888X", + "46786": "AB888X", + "46787": "AB888X", + "46788": "AB888X", + "46789": "AB888X", + "46791": "AB888X", + "46792": "AB888X", + "46793": "AB888X", + "46794": "AB888X", + "46795": "AB888X", + "46796": "AB888X", + "46797": "AB888X", + "46798": "AB888X", + "46799": "AB888X", + "46801": "AB888X", + "46802": "AB888X", + "46803": "AB888X", + "46804": "AB888X", + "46805": "AB888X", + "46806": "AB888X", + "46807": "AB888X", + "46808": "AB888X", + "46809": "AB888X", + "46814": "AB888X", + "46815": "AB888X", + "46816": "AB888X", + "46818": "AB888X", + "46819": "AB888X", + "46825": "AB888X", + "46835": "AB888X", + "46845": "AB888X", + "46850": "AB888X", + "46851": "AB888X", + "46852": "AB888X", + "46853": "AB888X", + "46854": "AB888X", + "46855": "AB888X", + "46856": "AB888X", + "46857": "AB888X", + "46858": "AB888X", + "46859": "AB888X", + "46860": "AB888X", + "46861": "AB888X", + "46862": "AB888X", + "46863": "AB888X", + "46864": "AB888X", + "46865": "AB888X", + "46866": "AB888X", + "46867": "AB888X", + "46868": "AB888X", + "46869": "AB888X", + "46885": "AB888X", + "46895": "AB888X", + "46896": "AB888X", + "46897": "AB888X", + "46898": "AB888X", + "46899": "AB888X", + "46901": "AB888X", + "46902": "AB888X", + "46903": "AB888X", + "46904": "AB888X", + "46910": "AB887X", + "46911": "AB888X", + "46912": "AB887X", + "46913": "AB888X", + "46914": "AB888X", + "46915": "AB888X", + "46916": "AB888X", + "46917": "AB888X", + "46919": "AB888X", + "46920": "AB888X", + "46921": "AB888X", + "46922": "AB887X", + "46923": "AB888X", + "46926": "AB888X", + "46928": "AB888X", + "46929": "AB888X", + "46930": "AB888X", + "46931": "AB887X", + "46932": "AB888X", + "46933": "AB888X", + "46935": "AB887X", + "46936": "AB888X", + "46937": "AB888X", + "46938": "AB888X", + "46939": "AB887X", + "46940": "AB888X", + "46941": "AB888X", + "46942": "AB888X", + "46943": "AB888X", + "46945": "AB887X", + "46946": "AB888X", + "46947": "AB888X", + "46950": "AB888X", + "46951": "AB888X", + "46952": "AB888X", + "46953": "AB888X", + "46957": "AB888X", + "46958": "AB888X", + "46959": "AB888X", + "46960": "AB887X", + "46961": "AB888X", + "46962": "AB888X", + "46965": "AB888X", + "46967": "AB888X", + "46968": "AB887X", + "46970": "AB888X", + "46971": "AB888X", + "46974": "AB888X", + "46975": "AB887X", + "46977": "AB888X", + "46978": "AB888X", + "46979": "AB888X", + "46980": "AB888X", + "46982": "AB888X", + "46984": "AB888X", + "46985": "AB887X", + "46986": "AB888X", + "46987": "AB888X", + "46988": "AB888X", + "46989": "AB888X", + "46990": "AB888X", + "46991": "AB888X", + "46992": "AB888X", + "46994": "AB888X", + "46995": "AB888X", + "46996": "AB887X", + "46998": "AB888X", + "47001": "AB890X", + "47003": "AB888X", + "47006": "AB888X", + "47010": "AB888X", + "47011": "AB888X", + "47012": "AB888X", + "47016": "AB888X", + "47017": "AB888X", + "47018": "AB890X", + "47019": "AB888X", + "47020": "AB888X", + "47021": "AB888X", + "47022": "AB890X", + "47023": "AB888X", + "47024": "AB888X", + "47025": "AB890X", + "47030": "AB888X", + "47031": "AB890X", + "47032": "AB890X", + "47033": "AB888X", + "47034": "AB888X", + "47035": "AB888X", + "47036": "AB888X", + "47037": "AB888X", + "47038": "AB888X", + "47039": "AB888X", + "47040": "AB890X", + "47041": "AB890X", + "47042": "AB888X", + "47043": "AB888X", + "47060": "AB890X", + "47102": "AB888X", + "47104": "AB888X", + "47106": "AB888X", + "47107": "AB888X", + "47108": "AB888X", + "47110": "AB888X", + "47111": "AB888X", + "47112": "AB888X", + "47114": "AB888X", + "47115": "AB888X", + "47116": "AB888X", + "47117": "AB888X", + "47118": "AB888X", + "47119": "AB888X", + "47120": "AB888X", + "47122": "AB888X", + "47123": "AB888X", + "47124": "AB888X", + "47125": "AB888X", + "47126": "AB888X", + "47129": "AB888X", + "47130": "AB888X", + "47131": "AB888X", + "47132": "AB888X", + "47133": "AB888X", + "47134": "AB888X", + "47135": "AB888X", + "47136": "AB888X", + "47137": "AB888X", + "47138": "AB888X", + "47139": "AB888X", + "47140": "AB888X", + "47141": "AB888X", + "47142": "AB888X", + "47143": "AB888X", + "47144": "AB888X", + "47145": "AB888X", + "47146": "AB888X", + "47147": "AB888X", + "47150": "AB888X", + "47151": "AB888X", + "47160": "AB888X", + "47161": "AB888X", + "47162": "AB888X", + "47163": "AB888X", + "47164": "AB888X", + "47165": "AB888X", + "47166": "AB888X", + "47167": "AB888X", + "47170": "AB888X", + "47172": "AB888X", + "47174": "AB888X", + "47175": "AB888X", + "47177": "AB888X", + "47190": "AB888X", + "47199": "AB888X", + "47201": "AB888X", + "47202": "AB888X", + "47203": "AB888X", + "47220": "AB888X", + "47223": "AB888X", + "47224": "AB888X", + "47225": "AB888X", + "47226": "AB888X", + "47227": "AB888X", + "47228": "AB888X", + "47229": "AB888X", + "47230": "AB888X", + "47231": "AB888X", + "47232": "AB888X", + "47234": "AB888X", + "47235": "AB888X", + "47236": "AB888X", + "47240": "AB888X", + "47243": "AB888X", + "47244": "AB888X", + "47245": "AB888X", + "47246": "AB888X", + "47247": "AB888X", + "47249": "AB888X", + "47250": "AB888X", + "47260": "AB888X", + "47261": "AB888X", + "47263": "AB888X", + "47264": "AB888X", + "47265": "AB888X", + "47270": "AB888X", + "47272": "AB888X", + "47273": "AB888X", + "47274": "AB888X", + "47280": "AB888X", + "47281": "AB888X", + "47282": "AB888X", + "47283": "AB888X", + "47302": "AB888X", + "47303": "AB888X", + "47304": "AB888X", + "47305": "AB888X", + "47306": "AB888X", + "47307": "AB888X", + "47308": "AB888X", + "47320": "AB888X", + "47322": "AB888X", + "47324": "AB888X", + "47325": "AB888X", + "47326": "AB888X", + "47327": "AB888X", + "47330": "AB888X", + "47331": "AB888X", + "47334": "AB888X", + "47335": "AB888X", + "47336": "AB888X", + "47337": "AB888X", + "47338": "AB888X", + "47339": "AB888X", + "47340": "AB888X", + "47341": "AB888X", + "47342": "AB888X", + "47344": "AB888X", + "47345": "AB888X", + "47346": "AB888X", + "47348": "AB888X", + "47351": "AB888X", + "47352": "AB888X", + "47353": "AB888X", + "47354": "AB888X", + "47355": "AB888X", + "47356": "AB888X", + "47357": "AB888X", + "47358": "AB888X", + "47359": "AB888X", + "47360": "AB888X", + "47361": "AB888X", + "47362": "AB888X", + "47366": "AB888X", + "47367": "AB888X", + "47368": "AB888X", + "47369": "AB888X", + "47370": "AB888X", + "47371": "AB888X", + "47373": "AB888X", + "47374": "AB888X", + "47375": "AB888X", + "47380": "AB888X", + "47381": "AB888X", + "47382": "AB888X", + "47383": "AB888X", + "47384": "AB888X", + "47385": "AB888X", + "47386": "AB888X", + "47387": "AB888X", + "47388": "AB888X", + "47390": "AB888X", + "47392": "AB888X", + "47393": "AB888X", + "47394": "AB888X", + "47396": "AB888X", + "47401": "AB888X", + "47402": "AB888X", + "47403": "AB888X", + "47404": "AB888X", + "47405": "AB888X", + "47406": "AB888X", + "47407": "AB888X", + "47408": "AB888X", + "47420": "AB888X", + "47421": "AB888X", + "47424": "AB888X", + "47426": "AB888X", + "47427": "AB888X", + "47429": "AB888X", + "47430": "AB888X", + "47431": "AB888X", + "47432": "AB888X", + "47433": "AB888X", + "47434": "AB888X", + "47435": "AB888X", + "47436": "AB888X", + "47437": "AB888X", + "47438": "AB888X", + "47439": "AB888X", + "47441": "AB888X", + "47443": "AB888X", + "47445": "AB888X", + "47446": "AB888X", + "47448": "AB888X", + "47449": "AB888X", + "47451": "AB888X", + "47452": "AB888X", + "47453": "AB888X", + "47454": "AB888X", + "47455": "AB888X", + "47456": "AB888X", + "47457": "AB888X", + "47458": "AB888X", + "47459": "AB888X", + "47460": "AB888X", + "47462": "AB888X", + "47463": "AB888X", + "47464": "AB888X", + "47465": "AB888X", + "47467": "AB888X", + "47468": "AB888X", + "47469": "AB888X", + "47470": "AB888X", + "47471": "AB888X", + "47472": "AB888X", + "47490": "AB888X", + "47501": "AB888X", + "47512": "AB888X", + "47513": "AB888X", + "47514": "AB888X", + "47515": "AB888X", + "47516": "AB888X", + "47519": "AB888X", + "47520": "AB888X", + "47521": "AB888X", + "47522": "AB888X", + "47523": "AB888X", + "47524": "AB888X", + "47525": "AB888X", + "47527": "AB888X", + "47528": "AB888X", + "47529": "AB888X", + "47531": "AB888X", + "47532": "AB888X", + "47535": "AB888X", + "47536": "AB888X", + "47537": "AB888X", + "47541": "AB888X", + "47542": "AB888X", + "47545": "AB888X", + "47546": "AB888X", + "47547": "AB888X", + "47549": "AB888X", + "47550": "AB888X", + "47551": "AB888X", + "47552": "AB888X", + "47553": "AB888X", + "47556": "AB888X", + "47557": "AB888X", + "47558": "AB888X", + "47561": "AB888X", + "47562": "AB888X", + "47564": "AB888X", + "47567": "AB888X", + "47568": "AB888X", + "47573": "AB888X", + "47574": "AB888X", + "47575": "AB888X", + "47576": "AB888X", + "47577": "AB888X", + "47578": "AB888X", + "47579": "AB888X", + "47580": "AB888X", + "47581": "AB888X", + "47584": "AB888X", + "47585": "AB888X", + "47586": "AB888X", + "47588": "AB888X", + "47590": "AB888X", + "47591": "AB888X", + "47596": "AB888X", + "47597": "AB888X", + "47598": "AB888X", + "47601": "AB888X", + "47610": "AB888X", + "47611": "AB888X", + "47612": "AB888X", + "47613": "AB888X", + "47614": "AB888X", + "47615": "AB888X", + "47616": "AB888X", + "47617": "AB888X", + "47618": "AB888X", + "47619": "AB888X", + "47620": "AB888X", + "47629": "AB888X", + "47630": "AB888X", + "47631": "AB888X", + "47633": "AB888X", + "47634": "AB888X", + "47635": "AB888X", + "47637": "AB888X", + "47638": "AB888X", + "47639": "AB888X", + "47640": "AB888X", + "47647": "AB888X", + "47648": "AB888X", + "47649": "AB888X", + "47654": "AB888X", + "47660": "AB888X", + "47665": "AB888X", + "47666": "AB888X", + "47670": "AB888X", + "47683": "AB888X", + "47701": "AB888X", + "47702": "AB888X", + "47703": "AB888X", + "47704": "AB888X", + "47705": "AB888X", + "47706": "AB888X", + "47708": "AB888X", + "47710": "AB888X", + "47711": "AB888X", + "47712": "AB888X", + "47713": "AB888X", + "47714": "AB888X", + "47715": "AB888X", + "47716": "AB888X", + "47719": "AB888X", + "47720": "AB888X", + "47721": "AB888X", + "47722": "AB888X", + "47724": "AB888X", + "47725": "AB888X", + "47727": "AB888X", + "47728": "AB888X", + "47730": "AB888X", + "47731": "AB888X", + "47732": "AB888X", + "47733": "AB888X", + "47734": "AB888X", + "47735": "AB888X", + "47736": "AB888X", + "47737": "AB888X", + "47739": "AB888X", + "47740": "AB888X", + "47741": "AB888X", + "47744": "AB888X", + "47747": "AB888X", + "47750": "AB888X", + "47801": "AB888X", + "47802": "AB888X", + "47803": "AB888X", + "47804": "AB888X", + "47805": "AB888X", + "47807": "AB888X", + "47808": "AB888X", + "47809": "AB888X", + "47811": "AB888X", + "47812": "AB888X", + "47813": "AB888X", + "47814": "AB888X", + "47830": "AB888X", + "47831": "AB888X", + "47832": "AB888X", + "47833": "AB888X", + "47834": "AB888X", + "47836": "AB888X", + "47837": "AB888X", + "47838": "AB888X", + "47840": "AB888X", + "47841": "AB888X", + "47842": "AB888X", + "47845": "AB888X", + "47846": "AB888X", + "47847": "AB888X", + "47848": "AB888X", + "47849": "AB888X", + "47850": "AB888X", + "47851": "AB888X", + "47852": "AB888X", + "47853": "AB888X", + "47854": "AB888X", + "47855": "AB888X", + "47856": "AB888X", + "47857": "AB888X", + "47858": "AB888X", + "47859": "AB888X", + "47860": "AB888X", + "47861": "AB888X", + "47862": "AB888X", + "47863": "AB888X", + "47864": "AB888X", + "47865": "AB888X", + "47866": "AB888X", + "47868": "AB888X", + "47869": "AB888X", + "47870": "AB888X", + "47871": "AB888X", + "47872": "AB888X", + "47874": "AB888X", + "47875": "AB888X", + "47876": "AB888X", + "47878": "AB888X", + "47879": "AB888X", + "47880": "AB888X", + "47881": "AB888X", + "47882": "AB888X", + "47884": "AB888X", + "47885": "AB888X", + "47901": "AB888X", + "47902": "AB888X", + "47903": "AB888X", + "47904": "AB888X", + "47905": "AB888X", + "47906": "AB888X", + "47907": "AB888X", + "47909": "AB888X", + "47916": "AB888X", + "47917": "AB888X", + "47918": "AB888X", + "47920": "AB888X", + "47921": "AB888X", + "47922": "AB888X", + "47923": "AB888X", + "47924": "AB888X", + "47925": "AB888X", + "47926": "AB888X", + "47928": "AB888X", + "47929": "AB888X", + "47930": "AB888X", + "47932": "AB888X", + "47933": "AB888X", + "47934": "AB888X", + "47935": "AB888X", + "47936": "AB888X", + "47937": "AB888X", + "47938": "AB888X", + "47939": "AB888X", + "47940": "AB888X", + "47941": "AB888X", + "47942": "AB888X", + "47943": "AB887X", + "47944": "AB888X", + "47946": "AB888X", + "47948": "AB888X", + "47949": "AB888X", + "47950": "AB888X", + "47951": "AB888X", + "47952": "AB888X", + "47954": "AB888X", + "47955": "AB888X", + "47957": "AB887X", + "47958": "AB888X", + "47959": "AB888X", + "47960": "AB888X", + "47962": "AB888X", + "47963": "AB888X", + "47964": "AB888X", + "47965": "AB888X", + "47966": "AB888X", + "47967": "AB888X", + "47968": "AB888X", + "47969": "AB888X", + "47970": "AB888X", + "47971": "AB888X", + "47974": "AB888X", + "47975": "AB888X", + "47977": "AB888X", + "47978": "AB887X", + "47980": "AB888X", + "47981": "AB888X", + "47982": "AB888X", + "47983": "AB888X", + "47984": "AB888X", + "47986": "AB888X", + "47987": "AB888X", + "47988": "AB888X", + "47989": "AB888X", + "47990": "AB888X", + "47991": "AB888X", + "47992": "AB888X", + "47993": "AB888X", + "47994": "AB888X", + "47995": "AB888X", + "47996": "AB888X", + "47997": "AB888X", + "48001": "AB889X", + "48002": "AB889X", + "48003": "AB889X", + "48004": "AB889X", + "48005": "AB889X", + "48006": "AB889X", + "48007": "AB889X", + "48009": "AB889X", + "48012": "AB889X", + "48014": "AB889X", + "48015": "AB889X", + "48017": "AB889X", + "48021": "AB889X", + "48022": "AB889X", + "48023": "AB889X", + "48025": "AB889X", + "48026": "AB889X", + "48027": "AB889X", + "48028": "AB889X", + "48030": "AB889X", + "48032": "AB889X", + "48033": "AB889X", + "48034": "AB889X", + "48035": "AB889X", + "48036": "AB889X", + "48037": "AB889X", + "48038": "AB889X", + "48039": "AB889X", + "48040": "AB889X", + "48041": "AB889X", + "48042": "AB889X", + "48043": "AB889X", + "48044": "AB889X", + "48045": "AB889X", + "48046": "AB889X", + "48047": "AB889X", + "48048": "AB889X", + "48049": "AB889X", + "48050": "AB889X", + "48051": "AB889X", + "48054": "AB889X", + "48059": "AB889X", + "48060": "AB889X", + "48061": "AB889X", + "48062": "AB889X", + "48063": "AB889X", + "48064": "AB889X", + "48065": "AB889X", + "48066": "AB889X", + "48067": "AB889X", + "48068": "AB889X", + "48069": "AB889X", + "48070": "AB889X", + "48071": "AB889X", + "48072": "AB889X", + "48073": "AB889X", + "48074": "AB889X", + "48075": "AB889X", + "48076": "AB889X", + "48079": "AB889X", + "48080": "AB889X", + "48081": "AB889X", + "48082": "AB889X", + "48083": "AB889X", + "48084": "AB889X", + "48085": "AB889X", + "48086": "AB889X", + "48088": "AB889X", + "48089": "AB889X", + "48090": "AB889X", + "48091": "AB889X", + "48092": "AB889X", + "48093": "AB889X", + "48094": "AB889X", + "48095": "AB889X", + "48096": "AB889X", + "48097": "AB889X", + "48098": "AB889X", + "48099": "AB889X", + "48101": "AB889X", + "48103": "AB889X", + "48104": "AB889X", + "48105": "AB889X", + "48106": "AB889X", + "48107": "AB889X", + "48108": "AB889X", + "48109": "AB889X", + "48110": "AB889X", + "48111": "AB889X", + "48112": "AB889X", + "48113": "AB889X", + "48114": "AB889X", + "48115": "AB889X", + "48116": "AB889X", + "48117": "AB889X", + "48118": "AB889X", + "48120": "AB889X", + "48121": "AB889X", + "48122": "AB889X", + "48123": "AB889X", + "48124": "AB889X", + "48125": "AB889X", + "48126": "AB889X", + "48127": "AB889X", + "48128": "AB889X", + "48130": "AB889X", + "48131": "AB889X", + "48133": "AB889X", + "48134": "AB889X", + "48135": "AB889X", + "48136": "AB889X", + "48137": "AB889X", + "48138": "AB889X", + "48139": "AB889X", + "48140": "AB889X", + "48141": "AB889X", + "48143": "AB889X", + "48144": "AB889X", + "48145": "AB889X", + "48146": "AB889X", + "48150": "AB889X", + "48151": "AB889X", + "48152": "AB889X", + "48153": "AB889X", + "48154": "AB889X", + "48157": "AB889X", + "48158": "AB889X", + "48159": "AB889X", + "48160": "AB889X", + "48161": "AB889X", + "48162": "AB889X", + "48164": "AB889X", + "48165": "AB889X", + "48166": "AB889X", + "48167": "AB889X", + "48168": "AB889X", + "48169": "AB889X", + "48170": "AB889X", + "48173": "AB889X", + "48174": "AB889X", + "48175": "AB889X", + "48176": "AB889X", + "48177": "AB889X", + "48178": "AB889X", + "48179": "AB889X", + "48180": "AB889X", + "48182": "AB889X", + "48183": "AB889X", + "48184": "AB889X", + "48185": "AB889X", + "48186": "AB889X", + "48187": "AB889X", + "48188": "AB889X", + "48189": "AB889X", + "48190": "AB889X", + "48191": "AB889X", + "48192": "AB889X", + "48193": "AB889X", + "48195": "AB889X", + "48197": "AB889X", + "48198": "AB889X", + "48201": "AB889X", + "48202": "AB889X", + "48203": "AB889X", + "48204": "AB889X", + "48205": "AB889X", + "48206": "AB889X", + "48207": "AB889X", + "48208": "AB889X", + "48209": "AB889X", + "48210": "AB889X", + "48211": "AB889X", + "48212": "AB889X", + "48213": "AB889X", + "48214": "AB889X", + "48215": "AB889X", + "48216": "AB889X", + "48217": "AB889X", + "48218": "AB889X", + "48219": "AB889X", + "48220": "AB889X", + "48221": "AB889X", + "48222": "AB889X", + "48223": "AB889X", + "48224": "AB889X", + "48225": "AB889X", + "48226": "AB889X", + "48227": "AB889X", + "48228": "AB889X", + "48229": "AB889X", + "48230": "AB889X", + "48231": "AB889X", + "48232": "AB889X", + "48233": "AB889X", + "48234": "AB889X", + "48235": "AB889X", + "48236": "AB889X", + "48237": "AB889X", + "48238": "AB889X", + "48239": "AB889X", + "48240": "AB889X", + "48242": "AB889X", + "48243": "AB889X", + "48244": "AB889X", + "48255": "AB889X", + "48260": "AB889X", + "48264": "AB889X", + "48265": "AB889X", + "48266": "AB889X", + "48267": "AB889X", + "48268": "AB889X", + "48269": "AB889X", + "48272": "AB889X", + "48275": "AB889X", + "48277": "AB889X", + "48278": "AB889X", + "48279": "AB889X", + "48283": "AB888X", + "48288": "AB889X", + "48301": "AB889X", + "48302": "AB889X", + "48303": "AB889X", + "48304": "AB889X", + "48306": "AB889X", + "48307": "AB889X", + "48308": "AB889X", + "48309": "AB889X", + "48310": "AB889X", + "48311": "AB889X", + "48312": "AB889X", + "48313": "AB889X", + "48314": "AB889X", + "48315": "AB889X", + "48316": "AB889X", + "48317": "AB889X", + "48318": "AB889X", + "48320": "AB889X", + "48321": "AB889X", + "48322": "AB889X", + "48323": "AB889X", + "48324": "AB889X", + "48325": "AB889X", + "48326": "AB889X", + "48327": "AB889X", + "48328": "AB889X", + "48329": "AB889X", + "48330": "AB889X", + "48331": "AB889X", + "48332": "AB889X", + "48333": "AB889X", + "48334": "AB889X", + "48335": "AB889X", + "48336": "AB889X", + "48340": "AB889X", + "48341": "AB889X", + "48342": "AB889X", + "48343": "AB889X", + "48346": "AB889X", + "48347": "AB889X", + "48348": "AB889X", + "48350": "AB889X", + "48353": "AB889X", + "48356": "AB889X", + "48357": "AB889X", + "48359": "AB889X", + "48360": "AB889X", + "48361": "AB889X", + "48362": "AB889X", + "48363": "AB889X", + "48366": "AB889X", + "48367": "AB889X", + "48370": "AB889X", + "48371": "AB889X", + "48374": "AB889X", + "48375": "AB889X", + "48376": "AB889X", + "48377": "AB889X", + "48380": "AB889X", + "48381": "AB889X", + "48382": "AB889X", + "48383": "AB889X", + "48386": "AB889X", + "48387": "AB889X", + "48390": "AB889X", + "48391": "AB889X", + "48393": "AB889X", + "48397": "AB889X", + "48401": "AB889X", + "48410": "AB889X", + "48411": "AB889X", + "48412": "AB889X", + "48413": "AB889X", + "48414": "AB889X", + "48415": "AB889X", + "48416": "AB889X", + "48417": "AB889X", + "48418": "AB889X", + "48419": "AB889X", + "48420": "AB889X", + "48421": "AB889X", + "48422": "AB889X", + "48423": "AB889X", + "48426": "AB889X", + "48427": "AB889X", + "48428": "AB889X", + "48429": "AB889X", + "48430": "AB889X", + "48432": "AB889X", + "48433": "AB889X", + "48434": "AB889X", + "48435": "AB889X", + "48436": "AB889X", + "48437": "AB889X", + "48438": "AB889X", + "48439": "AB889X", + "48440": "AB889X", + "48441": "AB889X", + "48442": "AB889X", + "48444": "AB889X", + "48445": "AB889X", + "48446": "AB889X", + "48449": "AB889X", + "48450": "AB889X", + "48451": "AB889X", + "48453": "AB889X", + "48454": "AB889X", + "48455": "AB889X", + "48456": "AB889X", + "48457": "AB889X", + "48458": "AB889X", + "48460": "AB889X", + "48461": "AB889X", + "48462": "AB889X", + "48463": "AB889X", + "48464": "AB889X", + "48465": "AB888X", + "48466": "AB889X", + "48467": "AB889X", + "48468": "AB889X", + "48469": "AB889X", + "48470": "AB889X", + "48471": "AB889X", + "48472": "AB889X", + "48473": "AB889X", + "48475": "AB889X", + "48476": "AB889X", + "48480": "AB889X", + "48501": "AB889X", + "48502": "AB889X", + "48503": "AB887X", + "48504": "AB889X", + "48505": "AB889X", + "48506": "AB889X", + "48507": "AB889X", + "48509": "AB889X", + "48519": "AB889X", + "48529": "AB889X", + "48531": "AB889X", + "48532": "AB889X", + "48550": "AB889X", + "48551": "AB889X", + "48552": "AB889X", + "48553": "AB889X", + "48554": "AB889X", + "48555": "AB889X", + "48556": "AB889X", + "48557": "AB889X", + "48559": "AB889X", + "48601": "AB889X", + "48602": "AB889X", + "48603": "AB889X", + "48604": "AB889X", + "48605": "AB889X", + "48606": "AB889X", + "48607": "AB889X", + "48608": "AB889X", + "48609": "AB889X", + "48610": "AB889X", + "48611": "AB889X", + "48612": "AB889X", + "48613": "AB889X", + "48614": "AB889X", + "48615": "AB889X", + "48616": "AB889X", + "48617": "AB889X", + "48618": "AB889X", + "48619": "AB889X", + "48620": "AB889X", + "48621": "AB889X", + "48622": "AB889X", + "48623": "AB889X", + "48624": "AB889X", + "48625": "AB889X", + "48626": "AB889X", + "48627": "AB889X", + "48628": "AB889X", + "48629": "AB889X", + "48630": "AB889X", + "48631": "AB889X", + "48632": "AB889X", + "48633": "AB889X", + "48634": "AB889X", + "48635": "AB889X", + "48636": "AB889X", + "48637": "AB889X", + "48638": "AB889X", + "48640": "AB889X", + "48641": "AB889X", + "48642": "AB889X", + "48647": "AB889X", + "48649": "AB889X", + "48650": "AB889X", + "48651": "AB889X", + "48652": "AB889X", + "48653": "AB889X", + "48654": "AB889X", + "48655": "AB889X", + "48656": "AB889X", + "48657": "AB889X", + "48658": "AB889X", + "48659": "AB889X", + "48661": "AB889X", + "48662": "AB889X", + "48663": "AB889X", + "48667": "AB889X", + "48670": "AB889X", + "48674": "AB889X", + "48686": "AB889X", + "48701": "AB889X", + "48703": "AB889X", + "48705": "AB889X", + "48706": "AB889X", + "48707": "AB889X", + "48708": "AB889X", + "48710": "AB889X", + "48720": "AB889X", + "48721": "AB889X", + "48722": "AB889X", + "48723": "AB889X", + "48724": "AB889X", + "48725": "AB889X", + "48726": "AB889X", + "48727": "AB889X", + "48728": "AB889X", + "48729": "AB889X", + "48730": "AB889X", + "48731": "AB889X", + "48732": "AB889X", + "48733": "AB889X", + "48734": "AB889X", + "48735": "AB889X", + "48736": "AB889X", + "48737": "AB889X", + "48738": "AB889X", + "48739": "AB889X", + "48740": "AB889X", + "48741": "AB889X", + "48742": "AB889X", + "48743": "AB889X", + "48744": "AB889X", + "48745": "AB889X", + "48746": "AB889X", + "48747": "AB889X", + "48748": "AB889X", + "48749": "AB889X", + "48750": "AB889X", + "48754": "AB889X", + "48755": "AB889X", + "48756": "AB889X", + "48757": "AB889X", + "48758": "AB889X", + "48759": "AB889X", + "48760": "AB889X", + "48761": "AB889X", + "48762": "AB889X", + "48763": "AB889X", + "48764": "AB889X", + "48765": "AB889X", + "48766": "AB889X", + "48767": "AB889X", + "48768": "AB889X", + "48769": "AB889X", + "48770": "AB889X", + "48787": "AB889X", + "48801": "AB889X", + "48802": "AB889X", + "48804": "AB889X", + "48805": "AB889X", + "48806": "AB889X", + "48807": "AB889X", + "48808": "AB889X", + "48809": "AB889X", + "48811": "AB889X", + "48812": "AB889X", + "48813": "AB889X", + "48815": "AB889X", + "48816": "AB889X", + "48817": "AB889X", + "48818": "AB889X", + "48819": "AB889X", + "48820": "AB889X", + "48821": "AB889X", + "48822": "AB889X", + "48823": "AB889X", + "48824": "AB889X", + "48825": "AB889X", + "48826": "AB889X", + "48827": "AB887X", + "48829": "AB889X", + "48830": "AB889X", + "48831": "AB889X", + "48832": "AB889X", + "48833": "AB889X", + "48834": "AB889X", + "48835": "AB889X", + "48836": "AB889X", + "48837": "AB889X", + "48838": "AB889X", + "48839": "AB889X", + "48840": "AB889X", + "48841": "AB889X", + "48842": "AB889X", + "48843": "AB889X", + "48844": "AB889X", + "48845": "AB889X", + "48846": "AB889X", + "48847": "AB889X", + "48848": "AB889X", + "48849": "AB889X", + "48850": "AB889X", + "48851": "AB889X", + "48852": "AB889X", + "48853": "AB889X", + "48854": "AB889X", + "48855": "AB889X", + "48856": "AB889X", + "48857": "AB889X", + "48858": "AB889X", + "48859": "AB889X", + "48860": "AB889X", + "48861": "AB889X", + "48862": "AB889X", + "48863": "AB889X", + "48864": "AB889X", + "48865": "AB889X", + "48866": "AB889X", + "48867": "AB889X", + "48870": "AB889X", + "48871": "AB889X", + "48872": "AB889X", + "48873": "AB889X", + "48874": "AB889X", + "48875": "AB889X", + "48876": "AB889X", + "48877": "AB889X", + "48878": "AB889X", + "48879": "AB889X", + "48880": "AB889X", + "48881": "AB889X", + "48882": "AB889X", + "48883": "AB889X", + "48884": "AB889X", + "48885": "AB889X", + "48886": "AB889X", + "48887": "AB889X", + "48888": "AB889X", + "48889": "AB889X", + "48890": "AB889X", + "48891": "AB889X", + "48892": "AB889X", + "48893": "AB889X", + "48894": "AB889X", + "48895": "AB889X", + "48896": "AB889X", + "48897": "AB889X", + "48901": "AB889X", + "48906": "AB889X", + "48907": "AB889X", + "48908": "AB889X", + "48909": "AB889X", + "48910": "AB889X", + "48911": "AB889X", + "48912": "AB889X", + "48913": "AB889X", + "48915": "AB889X", + "48916": "AB889X", + "48917": "AB889X", + "48918": "AB889X", + "48919": "AB889X", + "48921": "AB889X", + "48922": "AB889X", + "48924": "AB889X", + "48929": "AB889X", + "48930": "AB889X", + "48933": "AB889X", + "48937": "AB889X", + "48950": "AB889X", + "48951": "AB889X", + "48956": "AB889X", + "48980": "AB889X", + "49001": "AB889X", + "49002": "AB889X", + "49003": "AB889X", + "49004": "AB889X", + "49005": "AB889X", + "49006": "AB889X", + "49007": "AB889X", + "49008": "AB889X", + "49009": "AB889X", + "49010": "AB889X", + "49011": "AB889X", + "49012": "AB889X", + "49013": "AB889X", + "49014": "AB889X", + "49015": "AB889X", + "49016": "AB889X", + "49017": "AB889X", + "49018": "AB889X", + "49019": "AB889X", + "49020": "AB889X", + "49021": "AB889X", + "49022": "AB887X", + "49023": "AB889X", + "49024": "AB889X", + "49026": "AB889X", + "49027": "AB889X", + "49028": "AB889X", + "49029": "AB889X", + "49030": "AB889X", + "49031": "AB887X", + "49032": "AB889X", + "49033": "AB889X", + "49034": "AB889X", + "49035": "AB889X", + "49036": "AB889X", + "49038": "AB887X", + "49039": "AB887X", + "49040": "AB889X", + "49041": "AB889X", + "49042": "AB889X", + "49043": "AB889X", + "49045": "AB889X", + "49046": "AB889X", + "49047": "AB887X", + "49048": "AB889X", + "49050": "AB889X", + "49051": "AB889X", + "49052": "AB889X", + "49053": "AB889X", + "49055": "AB889X", + "49056": "AB889X", + "49057": "AB887X", + "49058": "AB889X", + "49060": "AB889X", + "49061": "AB887X", + "49062": "AB889X", + "49063": "AB889X", + "49064": "AB889X", + "49065": "AB889X", + "49066": "AB889X", + "49067": "AB889X", + "49068": "AB889X", + "49069": "AB889X", + "49070": "AB889X", + "49071": "AB889X", + "49072": "AB889X", + "49073": "AB889X", + "49074": "AB889X", + "49075": "AB889X", + "49076": "AB889X", + "49077": "AB889X", + "49078": "AB889X", + "49079": "AB889X", + "49080": "AB889X", + "49081": "AB889X", + "49082": "AB889X", + "49083": "AB889X", + "49084": "AB887X", + "49085": "AB887X", + "49087": "AB889X", + "49088": "AB889X", + "49089": "AB889X", + "49090": "AB889X", + "49091": "AB889X", + "49092": "AB889X", + "49093": "AB889X", + "49094": "AB889X", + "49095": "AB887X", + "49096": "AB889X", + "49097": "AB889X", + "49098": "AB887X", + "49099": "AB889X", + "49101": "AB887X", + "49102": "AB887X", + "49103": "AB887X", + "49104": "AB887X", + "49106": "AB887X", + "49107": "AB887X", + "49111": "AB887X", + "49112": "AB887X", + "49113": "AB887X", + "49115": "AB887X", + "49116": "AB887X", + "49117": "AB887X", + "49119": "AB887X", + "49120": "AB887X", + "49121": "AB887X", + "49125": "AB887X", + "49126": "AB887X", + "49127": "AB887X", + "49128": "AB887X", + "49129": "AB887X", + "49130": "AB887X", + "49201": "AB889X", + "49202": "AB889X", + "49203": "AB889X", + "49204": "AB889X", + "49220": "AB890X", + "49221": "AB890X", + "49224": "AB889X", + "49227": "AB889X", + "49228": "AB890X", + "49229": "AB890X", + "49230": "AB890X", + "49232": "AB889X", + "49233": "AB890X", + "49234": "AB889X", + "49235": "AB890X", + "49236": "AB890X", + "49237": "AB889X", + "49238": "AB890X", + "49239": "AB889X", + "49240": "AB889X", + "49241": "AB889X", + "49242": "AB889X", + "49245": "AB889X", + "49246": "AB889X", + "49247": "AB890X", + "49248": "AB890X", + "49249": "AB889X", + "49250": "AB889X", + "49251": "AB889X", + "49252": "AB889X", + "49253": "AB890X", + "49254": "AB889X", + "49255": "AB889X", + "49256": "AB890X", + "49257": "AB889X", + "49258": "AB889X", + "49259": "AB889X", + "49261": "AB889X", + "49262": "AB889X", + "49263": "AB889X", + "49264": "AB889X", + "49265": "AB890X", + "49266": "AB889X", + "49267": "AB889X", + "49268": "AB890X", + "49269": "AB889X", + "49270": "AB889X", + "49271": "AB889X", + "49272": "AB889X", + "49274": "AB889X", + "49276": "AB890X", + "49277": "AB889X", + "49279": "AB890X", + "49281": "AB889X", + "49282": "AB889X", + "49283": "AB889X", + "49284": "AB889X", + "49285": "AB889X", + "49286": "AB890X", + "49287": "AB890X", + "49288": "AB889X", + "49289": "AB890X", + "49301": "AB889X", + "49302": "AB889X", + "49303": "AB889X", + "49304": "AB889X", + "49305": "AB889X", + "49306": "AB889X", + "49307": "AB889X", + "49309": "AB889X", + "49310": "AB889X", + "49311": "AB889X", + "49312": "AB889X", + "49314": "AB889X", + "49315": "AB889X", + "49316": "AB889X", + "49317": "AB889X", + "49318": "AB889X", + "49319": "AB889X", + "49320": "AB889X", + "49321": "AB889X", + "49322": "AB889X", + "49323": "AB889X", + "49325": "AB889X", + "49326": "AB889X", + "49327": "AB889X", + "49328": "AB889X", + "49329": "AB889X", + "49330": "AB889X", + "49331": "AB889X", + "49332": "AB889X", + "49333": "AB889X", + "49335": "AB889X", + "49336": "AB889X", + "49337": "AB889X", + "49338": "AB889X", + "49339": "AB889X", + "49340": "AB889X", + "49341": "AB889X", + "49342": "AB889X", + "49343": "AB889X", + "49344": "AB889X", + "49345": "AB889X", + "49346": "AB889X", + "49347": "AB889X", + "49348": "AB889X", + "49349": "AB889X", + "49351": "AB889X", + "49355": "AB889X", + "49356": "AB889X", + "49357": "AB889X", + "49401": "AB889X", + "49402": "AB889X", + "49403": "AB889X", + "49404": "AB889X", + "49405": "AB889X", + "49406": "AB889X", + "49408": "AB889X", + "49409": "AB889X", + "49410": "AB889X", + "49411": "AB889X", + "49412": "AB889X", + "49413": "AB889X", + "49415": "AB889X", + "49416": "AB889X", + "49417": "AB889X", + "49418": "AB889X", + "49419": "AB889X", + "49420": "AB889X", + "49421": "AB889X", + "49422": "AB889X", + "49423": "AB889X", + "49424": "AB889X", + "49425": "AB889X", + "49426": "AB889X", + "49427": "AB889X", + "49428": "AB889X", + "49429": "AB889X", + "49430": "AB889X", + "49431": "AB889X", + "49434": "AB889X", + "49435": "AB889X", + "49436": "AB889X", + "49437": "AB889X", + "49440": "AB889X", + "49441": "AB889X", + "49442": "AB889X", + "49443": "AB889X", + "49444": "AB889X", + "49445": "AB889X", + "49446": "AB889X", + "49448": "AB889X", + "49449": "AB889X", + "49450": "AB889X", + "49451": "AB889X", + "49452": "AB889X", + "49453": "AB889X", + "49454": "AB889X", + "49455": "AB889X", + "49456": "AB889X", + "49457": "AB889X", + "49458": "AB889X", + "49459": "AB889X", + "49460": "AB889X", + "49461": "AB889X", + "49463": "AB889X", + "49464": "AB889X", + "49468": "AB889X", + "49501": "AB889X", + "49502": "AB889X", + "49503": "AB889X", + "49504": "AB889X", + "49505": "AB889X", + "49506": "AB889X", + "49507": "AB889X", + "49508": "AB889X", + "49509": "AB889X", + "49510": "AB889X", + "49512": "AB889X", + "49514": "AB889X", + "49515": "AB889X", + "49516": "AB889X", + "49518": "AB889X", + "49519": "AB889X", + "49523": "AB889X", + "49525": "AB889X", + "49528": "AB889X", + "49530": "AB889X", + "49534": "AB889X", + "49544": "AB889X", + "49546": "AB889X", + "49548": "AB889X", + "49550": "AB889X", + "49555": "AB889X", + "49560": "AB889X", + "49588": "AB889X", + "49599": "AB889X", + "49601": "AB889X", + "49610": "AB889X", + "49611": "AB889X", + "49612": "AB889X", + "49613": "AB889X", + "49614": "AB889X", + "49615": "AB889X", + "49616": "AB889X", + "49617": "AB889X", + "49618": "AB889X", + "49619": "AB889X", + "49620": "AB889X", + "49621": "AB889X", + "49622": "AB889X", + "49623": "AB889X", + "49625": "AB889X", + "49626": "AB889X", + "49627": "AB889X", + "49628": "AB889X", + "49629": "AB889X", + "49630": "AB889X", + "49631": "AB889X", + "49632": "AB889X", + "49633": "AB889X", + "49634": "AB889X", + "49635": "AB889X", + "49636": "AB889X", + "49637": "AB889X", + "49638": "AB889X", + "49639": "AB889X", + "49640": "AB889X", + "49642": "AB889X", + "49643": "AB889X", + "49644": "AB889X", + "49645": "AB889X", + "49646": "AB889X", + "49648": "AB889X", + "49649": "AB889X", + "49650": "AB889X", + "49651": "AB889X", + "49653": "AB889X", + "49654": "AB889X", + "49655": "AB889X", + "49656": "AB889X", + "49657": "AB889X", + "49659": "AB889X", + "49660": "AB889X", + "49663": "AB889X", + "49664": "AB889X", + "49665": "AB889X", + "49666": "AB889X", + "49667": "AB889X", + "49668": "AB889X", + "49670": "AB889X", + "49673": "AB889X", + "49674": "AB889X", + "49675": "AB889X", + "49676": "AB889X", + "49677": "AB889X", + "49679": "AB889X", + "49680": "AB889X", + "49682": "AB889X", + "49683": "AB889X", + "49684": "AB889X", + "49685": "AB889X", + "49686": "AB889X", + "49688": "AB889X", + "49689": "AB889X", + "49690": "AB889X", + "49696": "AB889X", + "49701": "AB889X", + "49705": "AB889X", + "49706": "AB889X", + "49707": "AB889X", + "49709": "AB889X", + "49710": "AB889X", + "49711": "AB889X", + "49712": "AB889X", + "49713": "AB889X", + "49715": "AB889X", + "49716": "AB889X", + "49717": "AB889X", + "49718": "AB889X", + "49719": "AB887X", + "49720": "AB889X", + "49721": "AB889X", + "49722": "AB889X", + "49723": "AB889X", + "49724": "AB889X", + "49725": "AB889X", + "49726": "AB889X", + "49727": "AB889X", + "49728": "AB889X", + "49729": "AB889X", + "49730": "AB889X", + "49733": "AB889X", + "49734": "AB889X", + "49735": "AB889X", + "49736": "AB889X", + "49737": "AB889X", + "49738": "AB889X", + "49739": "AB889X", + "49740": "AB889X", + "49743": "AB889X", + "49744": "AB889X", + "49745": "AB887X", + "49746": "AB889X", + "49747": "AB889X", + "49748": "AB889X", + "49749": "AB889X", + "49751": "AB889X", + "49752": "AB889X", + "49753": "AB889X", + "49755": "AB889X", + "49756": "AB889X", + "49757": "AB887X", + "49759": "AB889X", + "49760": "AB887X", + "49761": "AB889X", + "49762": "AB887X", + "49764": "AB889X", + "49765": "AB889X", + "49766": "AB889X", + "49768": "AB889X", + "49769": "AB889X", + "49770": "AB889X", + "49774": "AB889X", + "49775": "AB887X", + "49776": "AB889X", + "49777": "AB889X", + "49779": "AB889X", + "49780": "AB889X", + "49781": "AB889X", + "49782": "AB889X", + "49783": "AB889X", + "49784": "AB889X", + "49785": "AB889X", + "49786": "AB889X", + "49788": "AB889X", + "49790": "AB889X", + "49791": "AB889X", + "49792": "AB889X", + "49793": "AB889X", + "49795": "AB889X", + "49796": "AB889X", + "49797": "AB889X", + "49799": "AB889X", + "49801": "AB887X", + "49802": "AB887X", + "49805": "AB887X", + "49806": "AB887X", + "49807": "AB887X", + "49808": "AB887X", + "49812": "AB887X", + "49814": "AB887X", + "49815": "AB887X", + "49816": "AB887X", + "49817": "AB887X", + "49818": "AB887X", + "49819": "AB887X", + "49820": "AB887X", + "49821": "AB887X", + "49822": "AB887X", + "49825": "AB887X", + "49826": "AB887X", + "49827": "AB887X", + "49829": "AB887X", + "49831": "AB887X", + "49833": "AB887X", + "49834": "AB887X", + "49835": "AB887X", + "49836": "AB887X", + "49837": "AB887X", + "49838": "AB887X", + "49839": "AB887X", + "49840": "AB887X", + "49841": "AB887X", + "49845": "AB887X", + "49847": "AB887X", + "49848": "AB887X", + "49849": "AB887X", + "49852": "AB887X", + "49853": "AB887X", + "49854": "AB887X", + "49855": "AB887X", + "49858": "AB887X", + "49861": "AB887X", + "49862": "AB887X", + "49863": "AB887X", + "49864": "AB887X", + "49865": "AB887X", + "49866": "AB887X", + "49868": "AB887X", + "49870": "AB887X", + "49871": "AB887X", + "49872": "AB887X", + "49873": "AB887X", + "49874": "AB887X", + "49876": "AB887X", + "49877": "AB887X", + "49878": "AB887X", + "49879": "AB887X", + "49880": "AB887X", + "49881": "AB887X", + "49883": "AB887X", + "49884": "AB887X", + "49885": "AB887X", + "49886": "AB887X", + "49887": "AB887X", + "49891": "AB887X", + "49892": "AB887X", + "49893": "AB887X", + "49894": "AB887X", + "49895": "AB887X", + "49896": "AB887X", + "49901": "AB887X", + "49902": "AB887X", + "49903": "AB887X", + "49905": "AB887X", + "49908": "AB887X", + "49910": "AB889X", + "49911": "AB889X", + "49912": "AB889X", + "49913": "AB887X", + "49915": "AB887X", + "49916": "AB887X", + "49917": "AB887X", + "49918": "AB887X", + "49919": "AB887X", + "49920": "AB887X", + "49921": "AB887X", + "49922": "AB887X", + "49925": "AB889X", + "49927": "AB887X", + "49929": "AB889X", + "49930": "AB887X", + "49931": "AB887X", + "49934": "AB887X", + "49935": "AB887X", + "49938": "AB889X", + "49942": "AB887X", + "49945": "AB887X", + "49946": "AB887X", + "49947": "AB889X", + "49948": "AB887X", + "49950": "AB887X", + "49952": "AB887X", + "49953": "AB887X", + "49955": "AB887X", + "49958": "AB887X", + "49959": "AB889X", + "49960": "AB889X", + "49961": "AB887X", + "49962": "AB887X", + "49963": "AB887X", + "49964": "AB887X", + "49965": "AB887X", + "49967": "AB889X", + "49968": "AB889X", + "49969": "AB889X", + "49970": "AB887X", + "49971": "AB889X", + "50001": "AB888X", + "50002": "AB888X", + "50003": "AB888X", + "50005": "AB888X", + "50006": "AB888X", + "50007": "AB888X", + "50008": "AB888X", + "50009": "AB888X", + "50010": "AB888X", + "50011": "AB888X", + "50012": "AB888X", + "50013": "AB888X", + "50014": "AB888X", + "50020": "AB888X", + "50021": "AB888X", + "50022": "AB888X", + "50023": "AB888X", + "50025": "AB888X", + "50026": "AB888X", + "50027": "AB888X", + "50028": "AB888X", + "50029": "AB888X", + "50031": "AB888X", + "50032": "AB888X", + "50033": "AB888X", + "50034": "AB888X", + "50035": "AB888X", + "50036": "AB888X", + "50037": "AB888X", + "50038": "AB888X", + "50039": "AB888X", + "50040": "AB888X", + "50041": "AB888X", + "50042": "AB888X", + "50043": "AB888X", + "50044": "AB888X", + "50046": "AB888X", + "50047": "AB888X", + "50048": "AB888X", + "50049": "AB888X", + "50050": "AB888X", + "50051": "AB888X", + "50052": "AB888X", + "50054": "AB888X", + "50055": "AB888X", + "50056": "AB888X", + "50057": "AB888X", + "50058": "AB888X", + "50059": "AB888X", + "50060": "AB888X", + "50061": "AB888X", + "50062": "AB888X", + "50063": "AB888X", + "50064": "AB888X", + "50065": "AB888X", + "50066": "AB888X", + "50067": "AB888X", + "50068": "AB888X", + "50069": "AB888X", + "50070": "AB888X", + "50071": "AB888X", + "50072": "AB888X", + "50073": "AB888X", + "50074": "AB888X", + "50075": "AB888X", + "50076": "AB888X", + "50078": "AB888X", + "50101": "AB888X", + "50102": "AB888X", + "50103": "AB888X", + "50104": "AB888X", + "50105": "AB888X", + "50106": "AB888X", + "50107": "AB888X", + "50108": "AB888X", + "50109": "AB888X", + "50110": "AB888X", + "50111": "AB888X", + "50112": "AB888X", + "50115": "AB888X", + "50116": "AB888X", + "50117": "AB888X", + "50118": "AB888X", + "50119": "AB888X", + "50120": "AB888X", + "50122": "AB888X", + "50123": "AB888X", + "50124": "AB888X", + "50125": "AB888X", + "50126": "AB888X", + "50127": "AB888X", + "50128": "AB888X", + "50129": "AB888X", + "50130": "AB888X", + "50131": "AB888X", + "50132": "AB888X", + "50133": "AB888X", + "50134": "AB888X", + "50135": "AB888X", + "50136": "AB888X", + "50137": "AB888X", + "50138": "AB888X", + "50139": "AB888X", + "50140": "AB888X", + "50141": "AB888X", + "50142": "AB888X", + "50143": "AB888X", + "50144": "AB888X", + "50145": "AB888X", + "50146": "AB888X", + "50147": "AB888X", + "50148": "AB888X", + "50149": "AB888X", + "50150": "AB888X", + "50151": "AB888X", + "50152": "AB888X", + "50153": "AB888X", + "50154": "AB888X", + "50155": "AB888X", + "50156": "AB888X", + "50157": "AB888X", + "50158": "AB888X", + "50160": "AB888X", + "50161": "AB888X", + "50162": "AB888X", + "50163": "AB888X", + "50164": "AB888X", + "50165": "AB888X", + "50166": "AB888X", + "50167": "AB888X", + "50168": "AB888X", + "50169": "AB888X", + "50170": "AB888X", + "50171": "AB888X", + "50173": "AB888X", + "50174": "AB888X", + "50201": "AB888X", + "50206": "AB888X", + "50207": "AB888X", + "50208": "AB888X", + "50210": "AB888X", + "50211": "AB888X", + "50212": "AB888X", + "50213": "AB888X", + "50214": "AB888X", + "50216": "AB888X", + "50217": "AB888X", + "50218": "AB888X", + "50219": "AB888X", + "50220": "AB888X", + "50222": "AB888X", + "50223": "AB888X", + "50225": "AB888X", + "50226": "AB888X", + "50227": "AB888X", + "50228": "AB888X", + "50229": "AB888X", + "50230": "AB888X", + "50231": "AB888X", + "50232": "AB888X", + "50233": "AB888X", + "50234": "AB888X", + "50235": "AB888X", + "50236": "AB888X", + "50237": "AB888X", + "50238": "AB888X", + "50239": "AB888X", + "50240": "AB888X", + "50241": "AB888X", + "50242": "AB888X", + "50243": "AB888X", + "50244": "AB888X", + "50246": "AB888X", + "50247": "AB888X", + "50248": "AB888X", + "50249": "AB888X", + "50250": "AB888X", + "50251": "AB888X", + "50252": "AB888X", + "50254": "AB888X", + "50255": "AB888X", + "50256": "AB888X", + "50257": "AB888X", + "50258": "AB888X", + "50259": "AB888X", + "50261": "AB888X", + "50262": "AB888X", + "50263": "AB888X", + "50264": "AB888X", + "50265": "AB888X", + "50266": "AB888X", + "50268": "AB888X", + "50269": "AB888X", + "50271": "AB888X", + "50272": "AB888X", + "50273": "AB888X", + "50274": "AB888X", + "50275": "AB888X", + "50276": "AB888X", + "50277": "AB888X", + "50278": "AB888X", + "50301": "AB888X", + "50302": "AB888X", + "50303": "AB888X", + "50304": "AB888X", + "50305": "AB888X", + "50306": "AB888X", + "50307": "AB888X", + "50308": "AB888X", + "50309": "AB888X", + "50310": "AB888X", + "50311": "AB888X", + "50312": "AB888X", + "50313": "AB888X", + "50314": "AB888X", + "50315": "AB888X", + "50316": "AB888X", + "50317": "AB888X", + "50318": "AB888X", + "50319": "AB888X", + "50320": "AB888X", + "50321": "AB888X", + "50322": "AB888X", + "50323": "AB888X", + "50324": "AB888X", + "50325": "AB888X", + "50327": "AB888X", + "50328": "AB888X", + "50329": "AB888X", + "50330": "AB888X", + "50331": "AB888X", + "50332": "AB888X", + "50333": "AB888X", + "50334": "AB888X", + "50335": "AB888X", + "50336": "AB888X", + "50339": "AB888X", + "50340": "AB888X", + "50347": "AB888X", + "50350": "AB888X", + "50359": "AB888X", + "50360": "AB888X", + "50361": "AB888X", + "50362": "AB888X", + "50363": "AB888X", + "50364": "AB888X", + "50367": "AB888X", + "50368": "AB888X", + "50369": "AB888X", + "50380": "AB888X", + "50381": "AB888X", + "50391": "AB888X", + "50392": "AB888X", + "50393": "AB888X", + "50394": "AB888X", + "50395": "AB888X", + "50396": "AB888X", + "50397": "AB888X", + "50398": "AB888X", + "50401": "AB888X", + "50402": "AB888X", + "50420": "AB888X", + "50421": "AB888X", + "50423": "AB888X", + "50424": "AB889X", + "50426": "AB889X", + "50427": "AB888X", + "50428": "AB888X", + "50430": "AB888X", + "50431": "AB888X", + "50432": "AB888X", + "50433": "AB888X", + "50434": "AB889X", + "50435": "AB888X", + "50436": "AB889X", + "50438": "AB888X", + "50439": "AB888X", + "50440": "AB889X", + "50441": "AB888X", + "50444": "AB889X", + "50446": "AB889X", + "50447": "AB888X", + "50448": "AB889X", + "50449": "AB888X", + "50450": "AB889X", + "50451": "AB889X", + "50452": "AB888X", + "50453": "AB889X", + "50454": "AB889X", + "50455": "AB889X", + "50456": "AB889X", + "50457": "AB888X", + "50458": "AB888X", + "50459": "AB889X", + "50460": "AB889X", + "50461": "AB889X", + "50464": "AB888X", + "50465": "AB889X", + "50466": "AB889X", + "50467": "AB888X", + "50468": "AB888X", + "50469": "AB888X", + "50470": "AB888X", + "50471": "AB888X", + "50472": "AB889X", + "50473": "AB889X", + "50475": "AB888X", + "50476": "AB889X", + "50477": "AB888X", + "50478": "AB889X", + "50479": "AB888X", + "50480": "AB889X", + "50481": "AB889X", + "50482": "AB888X", + "50483": "AB889X", + "50484": "AB888X", + "50501": "AB888X", + "50510": "AB888X", + "50511": "AB889X", + "50514": "AB889X", + "50515": "AB888X", + "50516": "AB888X", + "50517": "AB889X", + "50518": "AB888X", + "50519": "AB888X", + "50520": "AB888X", + "50521": "AB888X", + "50522": "AB889X", + "50523": "AB888X", + "50524": "AB888X", + "50525": "AB888X", + "50526": "AB888X", + "50527": "AB888X", + "50528": "AB888X", + "50529": "AB888X", + "50530": "AB888X", + "50531": "AB889X", + "50532": "AB888X", + "50533": "AB888X", + "50535": "AB888X", + "50536": "AB888X", + "50538": "AB888X", + "50539": "AB889X", + "50540": "AB888X", + "50541": "AB888X", + "50542": "AB888X", + "50543": "AB888X", + "50544": "AB888X", + "50545": "AB888X", + "50546": "AB888X", + "50548": "AB888X", + "50551": "AB888X", + "50552": "AB888X", + "50554": "AB888X", + "50556": "AB889X", + "50557": "AB888X", + "50558": "AB888X", + "50559": "AB889X", + "50560": "AB889X", + "50561": "AB888X", + "50562": "AB888X", + "50563": "AB888X", + "50565": "AB888X", + "50566": "AB888X", + "50567": "AB888X", + "50568": "AB888X", + "50569": "AB888X", + "50570": "AB888X", + "50571": "AB888X", + "50573": "AB888X", + "50574": "AB888X", + "50575": "AB888X", + "50576": "AB888X", + "50577": "AB888X", + "50578": "AB889X", + "50579": "AB888X", + "50581": "AB888X", + "50582": "AB888X", + "50583": "AB888X", + "50585": "AB888X", + "50586": "AB888X", + "50588": "AB888X", + "50590": "AB889X", + "50591": "AB888X", + "50592": "AB888X", + "50593": "AB888X", + "50594": "AB888X", + "50595": "AB888X", + "50597": "AB888X", + "50598": "AB889X", + "50599": "AB888X", + "50601": "AB888X", + "50602": "AB888X", + "50603": "AB888X", + "50604": "AB888X", + "50605": "AB888X", + "50606": "AB888X", + "50607": "AB888X", + "50608": "AB888X", + "50609": "AB888X", + "50611": "AB888X", + "50612": "AB888X", + "50613": "AB888X", + "50614": "AB888X", + "50616": "AB888X", + "50619": "AB888X", + "50620": "AB888X", + "50621": "AB888X", + "50622": "AB888X", + "50623": "AB888X", + "50624": "AB888X", + "50625": "AB888X", + "50626": "AB888X", + "50627": "AB888X", + "50628": "AB889X", + "50629": "AB888X", + "50630": "AB888X", + "50631": "AB888X", + "50632": "AB888X", + "50633": "AB888X", + "50634": "AB888X", + "50635": "AB888X", + "50636": "AB888X", + "50638": "AB888X", + "50641": "AB888X", + "50642": "AB888X", + "50643": "AB888X", + "50644": "AB888X", + "50645": "AB888X", + "50647": "AB888X", + "50648": "AB888X", + "50649": "AB888X", + "50650": "AB888X", + "50651": "AB888X", + "50652": "AB888X", + "50653": "AB888X", + "50654": "AB888X", + "50655": "AB888X", + "50657": "AB888X", + "50658": "AB888X", + "50659": "AB888X", + "50660": "AB888X", + "50661": "AB888X", + "50662": "AB888X", + "50664": "AB888X", + "50665": "AB888X", + "50666": "AB888X", + "50667": "AB888X", + "50668": "AB888X", + "50669": "AB888X", + "50670": "AB888X", + "50671": "AB888X", + "50672": "AB888X", + "50673": "AB888X", + "50674": "AB888X", + "50675": "AB888X", + "50676": "AB888X", + "50677": "AB888X", + "50680": "AB888X", + "50681": "AB888X", + "50682": "AB888X", + "50701": "AB888X", + "50702": "AB888X", + "50703": "AB888X", + "50704": "AB888X", + "50706": "AB888X", + "50707": "AB888X", + "50801": "AB888X", + "50830": "AB888X", + "50831": "AB888X", + "50833": "AB888X", + "50835": "AB888X", + "50836": "AB888X", + "50837": "AB888X", + "50839": "AB888X", + "50840": "AB888X", + "50841": "AB888X", + "50842": "AB888X", + "50843": "AB888X", + "50845": "AB888X", + "50846": "AB888X", + "50847": "AB888X", + "50848": "AB888X", + "50849": "AB888X", + "50851": "AB888X", + "50853": "AB888X", + "50854": "AB888X", + "50857": "AB888X", + "50858": "AB888X", + "50859": "AB888X", + "50860": "AB888X", + "50861": "AB888X", + "50862": "AB888X", + "50863": "AB888X", + "50864": "AB888X", + "50936": "AB888X", + "50940": "AB888X", + "50947": "AB888X", + "50950": "AB888X", + "50980": "AB888X", + "50981": "AB888X", + "51001": "AB891X", + "51002": "AB888X", + "51003": "AB891X", + "51004": "AB891X", + "51005": "AB888X", + "51006": "AB888X", + "51007": "AB891X", + "51008": "AB891X", + "51009": "AB888X", + "51010": "AB891X", + "51011": "AB891X", + "51012": "AB888X", + "51014": "AB888X", + "51015": "AB891X", + "51016": "AB891X", + "51018": "AB891X", + "51019": "AB891X", + "51020": "AB888X", + "51022": "AB891X", + "51023": "AB891X", + "51024": "AB891X", + "51025": "AB888X", + "51026": "AB891X", + "51027": "AB891X", + "51028": "AB891X", + "51029": "AB888X", + "51030": "AB891X", + "51031": "AB891X", + "51033": "AB888X", + "51034": "AB891X", + "51035": "AB888X", + "51036": "AB891X", + "51037": "AB888X", + "51038": "AB891X", + "51039": "AB891X", + "51040": "AB891X", + "51041": "AB891X", + "51044": "AB891X", + "51045": "AB891X", + "51046": "AB888X", + "51047": "AB888X", + "51048": "AB891X", + "51049": "AB888X", + "51050": "AB891X", + "51051": "AB891X", + "51052": "AB891X", + "51053": "AB888X", + "51054": "AB891X", + "51055": "AB891X", + "51056": "AB891X", + "51058": "AB888X", + "51060": "AB891X", + "51061": "AB888X", + "51062": "AB891X", + "51063": "AB891X", + "51101": "AB891X", + "51102": "AB891X", + "51103": "AB891X", + "51104": "AB891X", + "51105": "AB891X", + "51106": "AB891X", + "51108": "AB891X", + "51109": "AB891X", + "51111": "AB891X", + "51201": "AB888X", + "51230": "AB891X", + "51231": "AB888X", + "51232": "AB889X", + "51234": "AB891X", + "51235": "AB891X", + "51237": "AB891X", + "51238": "AB891X", + "51239": "AB891X", + "51240": "AB891X", + "51241": "AB891X", + "51242": "AB891X", + "51243": "AB891X", + "51244": "AB891X", + "51245": "AB888X", + "51246": "AB891X", + "51247": "AB891X", + "51248": "AB888X", + "51249": "AB889X", + "51250": "AB891X", + "51301": "AB888X", + "51331": "AB889X", + "51333": "AB888X", + "51334": "AB889X", + "51338": "AB888X", + "51340": "AB888X", + "51341": "AB888X", + "51342": "AB888X", + "51343": "AB888X", + "51344": "AB889X", + "51345": "AB889X", + "51346": "AB888X", + "51347": "AB889X", + "51350": "AB889X", + "51351": "AB889X", + "51354": "AB889X", + "51355": "AB889X", + "51357": "AB888X", + "51358": "AB888X", + "51360": "AB889X", + "51363": "AB889X", + "51364": "AB889X", + "51365": "AB889X", + "51366": "AB888X", + "51401": "AB888X", + "51430": "AB888X", + "51431": "AB888X", + "51432": "AB888X", + "51433": "AB888X", + "51436": "AB888X", + "51439": "AB888X", + "51440": "AB888X", + "51441": "AB888X", + "51442": "AB888X", + "51443": "AB888X", + "51444": "AB888X", + "51445": "AB888X", + "51446": "AB888X", + "51447": "AB888X", + "51448": "AB888X", + "51449": "AB888X", + "51450": "AB888X", + "51451": "AB888X", + "51452": "AB888X", + "51453": "AB888X", + "51454": "AB888X", + "51455": "AB888X", + "51458": "AB888X", + "51459": "AB888X", + "51460": "AB888X", + "51461": "AB888X", + "51462": "AB888X", + "51463": "AB888X", + "51465": "AB888X", + "51466": "AB888X", + "51467": "AB888X", + "51501": "AB889X", + "51502": "AB889X", + "51503": "AB889X", + "51510": "AB889X", + "51520": "AB888X", + "51521": "AB889X", + "51523": "AB891X", + "51525": "AB889X", + "51526": "AB889X", + "51527": "AB888X", + "51528": "AB888X", + "51529": "AB889X", + "51530": "AB888X", + "51531": "AB888X", + "51532": "AB888X", + "51533": "AB889X", + "51534": "AB889X", + "51535": "AB888X", + "51536": "AB889X", + "51537": "AB888X", + "51540": "AB889X", + "51541": "AB889X", + "51542": "AB889X", + "51543": "AB888X", + "51544": "AB888X", + "51545": "AB889X", + "51546": "AB889X", + "51548": "AB889X", + "51549": "AB889X", + "51550": "AB889X", + "51551": "AB889X", + "51552": "AB888X", + "51553": "AB889X", + "51554": "AB889X", + "51555": "AB889X", + "51556": "AB889X", + "51557": "AB889X", + "51558": "AB891X", + "51559": "AB889X", + "51560": "AB889X", + "51561": "AB889X", + "51562": "AB888X", + "51563": "AB889X", + "51564": "AB889X", + "51565": "AB888X", + "51566": "AB888X", + "51570": "AB889X", + "51571": "AB889X", + "51572": "AB891X", + "51573": "AB888X", + "51575": "AB889X", + "51576": "AB889X", + "51577": "AB889X", + "51578": "AB888X", + "51579": "AB889X", + "51591": "AB888X", + "51593": "AB888X", + "51601": "AB888X", + "51602": "AB888X", + "51603": "AB888X", + "51630": "AB888X", + "51631": "AB888X", + "51632": "AB888X", + "51636": "AB888X", + "51637": "AB888X", + "51638": "AB888X", + "51639": "AB889X", + "51640": "AB889X", + "51645": "AB889X", + "51646": "AB888X", + "51647": "AB888X", + "51648": "AB889X", + "51649": "AB889X", + "51650": "AB889X", + "51651": "AB888X", + "51652": "AB889X", + "51653": "AB889X", + "51654": "AB889X", + "51656": "AB888X", + "52001": "AB888X", + "52002": "AB888X", + "52003": "AB888X", + "52004": "AB888X", + "52030": "AB888X", + "52031": "AB888X", + "52032": "AB888X", + "52033": "AB888X", + "52035": "AB888X", + "52036": "AB888X", + "52037": "AB888X", + "52038": "AB888X", + "52039": "AB888X", + "52040": "AB888X", + "52041": "AB888X", + "52042": "AB888X", + "52043": "AB888X", + "52044": "AB888X", + "52045": "AB888X", + "52046": "AB888X", + "52047": "AB888X", + "52048": "AB888X", + "52049": "AB888X", + "52050": "AB888X", + "52052": "AB888X", + "52053": "AB888X", + "52054": "AB888X", + "52056": "AB888X", + "52057": "AB888X", + "52060": "AB888X", + "52064": "AB888X", + "52065": "AB888X", + "52066": "AB888X", + "52068": "AB888X", + "52069": "AB888X", + "52070": "AB888X", + "52071": "AB888X", + "52072": "AB888X", + "52073": "AB888X", + "52074": "AB888X", + "52075": "AB888X", + "52076": "AB888X", + "52077": "AB888X", + "52078": "AB888X", + "52079": "AB888X", + "52099": "AB888X", + "52101": "AB888X", + "52132": "AB888X", + "52133": "AB888X", + "52134": "AB889X", + "52135": "AB888X", + "52136": "AB889X", + "52140": "AB889X", + "52141": "AB888X", + "52142": "AB888X", + "52144": "AB888X", + "52146": "AB889X", + "52147": "AB888X", + "52149": "AB888X", + "52151": "AB889X", + "52154": "AB888X", + "52155": "AB889X", + "52156": "AB888X", + "52157": "AB888X", + "52158": "AB888X", + "52159": "AB888X", + "52160": "AB889X", + "52161": "AB888X", + "52162": "AB889X", + "52163": "AB889X", + "52164": "AB888X", + "52165": "AB888X", + "52166": "AB888X", + "52168": "AB888X", + "52169": "AB888X", + "52170": "AB889X", + "52171": "AB888X", + "52172": "AB889X", + "52175": "AB888X", + "52201": "AB888X", + "52202": "AB888X", + "52203": "AB888X", + "52204": "AB888X", + "52205": "AB888X", + "52206": "AB888X", + "52207": "AB888X", + "52208": "AB888X", + "52209": "AB888X", + "52210": "AB888X", + "52211": "AB888X", + "52212": "AB888X", + "52213": "AB888X", + "52214": "AB888X", + "52215": "AB888X", + "52216": "AB888X", + "52217": "AB888X", + "52218": "AB888X", + "52219": "AB888X", + "52220": "AB888X", + "52221": "AB888X", + "52222": "AB888X", + "52223": "AB888X", + "52224": "AB888X", + "52225": "AB888X", + "52227": "AB888X", + "52228": "AB888X", + "52229": "AB888X", + "52231": "AB888X", + "52232": "AB888X", + "52233": "AB888X", + "52235": "AB888X", + "52236": "AB888X", + "52237": "AB888X", + "52240": "AB888X", + "52241": "AB888X", + "52242": "AB888X", + "52243": "AB888X", + "52244": "AB888X", + "52245": "AB888X", + "52246": "AB888X", + "52247": "AB888X", + "52248": "AB888X", + "52249": "AB888X", + "52251": "AB888X", + "52252": "AB888X", + "52253": "AB888X", + "52254": "AB888X", + "52255": "AB888X", + "52257": "AB888X", + "52301": "AB888X", + "52302": "AB888X", + "52305": "AB888X", + "52306": "AB888X", + "52307": "AB888X", + "52308": "AB888X", + "52309": "AB888X", + "52310": "AB888X", + "52312": "AB888X", + "52313": "AB888X", + "52314": "AB888X", + "52315": "AB888X", + "52316": "AB888X", + "52317": "AB888X", + "52318": "AB888X", + "52319": "AB888X", + "52320": "AB888X", + "52321": "AB888X", + "52322": "AB888X", + "52323": "AB888X", + "52324": "AB888X", + "52325": "AB888X", + "52326": "AB888X", + "52327": "AB888X", + "52328": "AB888X", + "52329": "AB888X", + "52330": "AB888X", + "52332": "AB888X", + "52333": "AB888X", + "52334": "AB888X", + "52335": "AB888X", + "52336": "AB888X", + "52337": "AB888X", + "52338": "AB888X", + "52339": "AB888X", + "52340": "AB888X", + "52341": "AB888X", + "52342": "AB888X", + "52344": "AB888X", + "52345": "AB888X", + "52346": "AB888X", + "52347": "AB888X", + "52348": "AB888X", + "52349": "AB888X", + "52350": "AB888X", + "52351": "AB888X", + "52352": "AB888X", + "52353": "AB888X", + "52354": "AB888X", + "52355": "AB888X", + "52356": "AB888X", + "52358": "AB888X", + "52359": "AB888X", + "52361": "AB888X", + "52362": "AB888X", + "52401": "AB888X", + "52402": "AB888X", + "52403": "AB888X", + "52404": "AB888X", + "52405": "AB888X", + "52406": "AB888X", + "52407": "AB888X", + "52408": "AB888X", + "52409": "AB888X", + "52410": "AB888X", + "52411": "AB888X", + "52497": "AB888X", + "52498": "AB888X", + "52499": "AB888X", + "52501": "AB888X", + "52530": "AB888X", + "52531": "AB888X", + "52533": "AB888X", + "52534": "AB888X", + "52535": "AB888X", + "52536": "AB888X", + "52537": "AB888X", + "52538": "AB888X", + "52540": "AB888X", + "52542": "AB888X", + "52543": "AB888X", + "52544": "AB888X", + "52548": "AB888X", + "52549": "AB888X", + "52550": "AB888X", + "52551": "AB888X", + "52552": "AB888X", + "52553": "AB888X", + "52554": "AB888X", + "52555": "AB888X", + "52556": "AB888X", + "52557": "AB888X", + "52560": "AB888X", + "52561": "AB888X", + "52562": "AB888X", + "52563": "AB888X", + "52565": "AB888X", + "52566": "AB888X", + "52567": "AB888X", + "52568": "AB888X", + "52569": "AB888X", + "52570": "AB888X", + "52571": "AB888X", + "52572": "AB888X", + "52573": "AB888X", + "52574": "AB888X", + "52576": "AB888X", + "52577": "AB888X", + "52580": "AB888X", + "52581": "AB888X", + "52583": "AB888X", + "52584": "AB888X", + "52585": "AB888X", + "52586": "AB888X", + "52588": "AB888X", + "52590": "AB888X", + "52591": "AB888X", + "52593": "AB888X", + "52594": "AB888X", + "52595": "AB888X", + "52601": "AB888X", + "52619": "AB888X", + "52620": "AB888X", + "52621": "AB888X", + "52623": "AB888X", + "52624": "AB888X", + "52625": "AB888X", + "52626": "AB888X", + "52627": "AB888X", + "52630": "AB888X", + "52631": "AB888X", + "52632": "AB888X", + "52635": "AB888X", + "52637": "AB888X", + "52638": "AB888X", + "52639": "AB888X", + "52640": "AB888X", + "52641": "AB888X", + "52642": "AB888X", + "52644": "AB888X", + "52645": "AB888X", + "52646": "AB888X", + "52647": "AB888X", + "52648": "AB888X", + "52649": "AB888X", + "52650": "AB888X", + "52651": "AB888X", + "52652": "AB888X", + "52653": "AB888X", + "52654": "AB888X", + "52655": "AB888X", + "52656": "AB888X", + "52657": "AB888X", + "52658": "AB888X", + "52659": "AB888X", + "52660": "AB888X", + "52701": "AB888X", + "52720": "AB888X", + "52721": "AB888X", + "52722": "AB888X", + "52726": "AB888X", + "52727": "AB888X", + "52728": "AB888X", + "52729": "AB888X", + "52730": "AB888X", + "52731": "AB888X", + "52732": "AB888X", + "52733": "AB888X", + "52734": "AB888X", + "52736": "AB888X", + "52737": "AB888X", + "52738": "AB888X", + "52739": "AB888X", + "52742": "AB888X", + "52745": "AB888X", + "52746": "AB888X", + "52747": "AB888X", + "52748": "AB888X", + "52749": "AB888X", + "52750": "AB888X", + "52751": "AB888X", + "52752": "AB888X", + "52753": "AB888X", + "52754": "AB888X", + "52755": "AB888X", + "52756": "AB888X", + "52757": "AB888X", + "52758": "AB888X", + "52759": "AB888X", + "52760": "AB888X", + "52761": "AB888X", + "52765": "AB888X", + "52766": "AB888X", + "52767": "AB888X", + "52768": "AB888X", + "52769": "AB888X", + "52771": "AB888X", + "52772": "AB888X", + "52773": "AB888X", + "52774": "AB888X", + "52776": "AB888X", + "52777": "AB888X", + "52778": "AB888X", + "52801": "AB888X", + "52802": "AB888X", + "52803": "AB888X", + "52804": "AB888X", + "52805": "AB888X", + "52806": "AB888X", + "52807": "AB888X", + "52808": "AB888X", + "52809": "AB888X", + "53001": "AB887X", + "53002": "AB887X", + "53003": "AB887X", + "53004": "AB887X", + "53005": "AB887X", + "53006": "AB887X", + "53007": "AB887X", + "53008": "AB887X", + "53010": "AB887X", + "53011": "AB887X", + "53012": "AB887X", + "53013": "AB887X", + "53014": "AB887X", + "53015": "AB887X", + "53016": "AB887X", + "53017": "AB887X", + "53018": "AB887X", + "53019": "AB887X", + "53020": "AB887X", + "53021": "AB887X", + "53022": "AB887X", + "53023": "AB887X", + "53024": "AB887X", + "53026": "AB887X", + "53027": "AB887X", + "53029": "AB887X", + "53031": "AB887X", + "53032": "AB887X", + "53033": "AB887X", + "53034": "AB887X", + "53035": "AB887X", + "53036": "AB887X", + "53037": "AB887X", + "53038": "AB887X", + "53039": "AB887X", + "53040": "AB887X", + "53042": "AB887X", + "53044": "AB887X", + "53045": "AB887X", + "53046": "AB887X", + "53047": "AB887X", + "53048": "AB887X", + "53049": "AB887X", + "53050": "AB887X", + "53051": "AB887X", + "53052": "AB887X", + "53056": "AB887X", + "53057": "AB887X", + "53058": "AB887X", + "53059": "AB887X", + "53060": "AB887X", + "53061": "AB887X", + "53062": "AB887X", + "53063": "AB887X", + "53064": "AB887X", + "53065": "AB887X", + "53066": "AB887X", + "53069": "AB887X", + "53070": "AB887X", + "53072": "AB887X", + "53073": "AB887X", + "53074": "AB887X", + "53075": "AB887X", + "53076": "AB887X", + "53078": "AB887X", + "53079": "AB887X", + "53080": "AB887X", + "53081": "AB887X", + "53082": "AB887X", + "53083": "AB887X", + "53085": "AB887X", + "53086": "AB887X", + "53088": "AB887X", + "53089": "AB887X", + "53090": "AB887X", + "53091": "AB887X", + "53092": "AB887X", + "53093": "AB887X", + "53094": "AB887X", + "53095": "AB887X", + "53097": "AB887X", + "53098": "AB887X", + "53099": "AB887X", + "53101": "AB887X", + "53102": "AB887X", + "53103": "AB887X", + "53104": "AB887X", + "53105": "AB887X", + "53108": "AB887X", + "53109": "AB887X", + "53110": "AB887X", + "53114": "AB887X", + "53115": "AB887X", + "53118": "AB887X", + "53119": "AB887X", + "53120": "AB887X", + "53121": "AB887X", + "53122": "AB887X", + "53125": "AB887X", + "53126": "AB887X", + "53127": "AB887X", + "53128": "AB887X", + "53129": "AB887X", + "53130": "AB887X", + "53132": "AB887X", + "53137": "AB887X", + "53138": "AB887X", + "53139": "AB887X", + "53140": "AB887X", + "53141": "AB887X", + "53142": "AB887X", + "53143": "AB887X", + "53144": "AB887X", + "53146": "AB887X", + "53147": "AB887X", + "53148": "AB887X", + "53149": "AB887X", + "53150": "AB887X", + "53151": "AB887X", + "53152": "AB887X", + "53153": "AB887X", + "53154": "AB887X", + "53156": "AB887X", + "53157": "AB887X", + "53158": "AB887X", + "53159": "AB887X", + "53167": "AB887X", + "53168": "AB887X", + "53170": "AB887X", + "53171": "AB887X", + "53172": "AB887X", + "53176": "AB887X", + "53177": "AB887X", + "53178": "AB887X", + "53179": "AB887X", + "53181": "AB887X", + "53182": "AB887X", + "53183": "AB887X", + "53184": "AB887X", + "53185": "AB887X", + "53186": "AB887X", + "53187": "AB887X", + "53188": "AB887X", + "53189": "AB887X", + "53190": "AB887X", + "53191": "AB887X", + "53192": "AB887X", + "53194": "AB887X", + "53195": "AB887X", + "53199": "AB887X", + "53201": "AB887X", + "53202": "AB887X", + "53203": "AB887X", + "53204": "AB887X", + "53205": "AB887X", + "53206": "AB887X", + "53207": "AB887X", + "53208": "AB887X", + "53209": "AB887X", + "53210": "AB887X", + "53211": "AB887X", + "53212": "AB887X", + "53213": "AB887X", + "53214": "AB887X", + "53215": "AB887X", + "53216": "AB887X", + "53217": "AB889X", + "53218": "AB887X", + "53219": "AB887X", + "53220": "AB887X", + "53221": "AB887X", + "53222": "AB887X", + "53223": "AB887X", + "53224": "AB887X", + "53225": "AB887X", + "53226": "AB887X", + "53227": "AB887X", + "53228": "AB887X", + "53233": "AB887X", + "53234": "AB887X", + "53235": "AB887X", + "53237": "AB887X", + "53244": "AB887X", + "53259": "AB887X", + "53263": "AB887X", + "53267": "AB887X", + "53268": "AB887X", + "53274": "AB887X", + "53278": "AB887X", + "53288": "AB887X", + "53290": "AB887X", + "53293": "AB887X", + "53295": "AB887X", + "53401": "AB887X", + "53402": "AB887X", + "53403": "AB887X", + "53404": "AB887X", + "53405": "AB887X", + "53406": "AB887X", + "53407": "AB887X", + "53408": "AB887X", + "53490": "AB887X", + "53501": "AB887X", + "53502": "AB887X", + "53503": "AB887X", + "53504": "AB887X", + "53505": "AB887X", + "53506": "AB887X", + "53507": "AB887X", + "53508": "AB887X", + "53510": "AB887X", + "53511": "AB887X", + "53512": "AB887X", + "53515": "AB887X", + "53516": "AB887X", + "53517": "AB887X", + "53518": "AB887X", + "53520": "AB887X", + "53521": "AB887X", + "53522": "AB887X", + "53523": "AB887X", + "53525": "AB887X", + "53526": "AB887X", + "53527": "AB887X", + "53528": "AB887X", + "53529": "AB887X", + "53530": "AB888X", + "53531": "AB887X", + "53532": "AB887X", + "53533": "AB887X", + "53534": "AB887X", + "53535": "AB887X", + "53536": "AB887X", + "53537": "AB887X", + "53538": "AB887X", + "53540": "AB887X", + "53541": "AB887X", + "53542": "AB887X", + "53543": "AB887X", + "53544": "AB887X", + "53545": "AB887X", + "53546": "AB887X", + "53547": "AB887X", + "53548": "AB887X", + "53549": "AB887X", + "53550": "AB887X", + "53551": "AB887X", + "53553": "AB887X", + "53554": "AB887X", + "53555": "AB887X", + "53556": "AB887X", + "53557": "AB887X", + "53558": "AB887X", + "53559": "AB887X", + "53560": "AB887X", + "53561": "AB887X", + "53562": "AB887X", + "53563": "AB887X", + "53565": "AB887X", + "53566": "AB887X", + "53569": "AB887X", + "53570": "AB887X", + "53571": "AB887X", + "53572": "AB887X", + "53573": "AB887X", + "53574": "AB887X", + "53575": "AB887X", + "53576": "AB887X", + "53577": "AB887X", + "53578": "AB887X", + "53579": "AB887X", + "53580": "AB887X", + "53581": "AB887X", + "53582": "AB887X", + "53583": "AB887X", + "53584": "AB887X", + "53585": "AB887X", + "53586": "AB888X", + "53587": "AB887X", + "53588": "AB887X", + "53589": "AB887X", + "53590": "AB887X", + "53593": "AB887X", + "53594": "AB887X", + "53595": "AB887X", + "53596": "AB887X", + "53597": "AB887X", + "53598": "AB887X", + "53599": "AB887X", + "53701": "AB887X", + "53702": "AB887X", + "53703": "AB887X", + "53704": "AB887X", + "53705": "AB887X", + "53706": "AB887X", + "53707": "AB887X", + "53708": "AB887X", + "53711": "AB887X", + "53713": "AB887X", + "53714": "AB887X", + "53715": "AB887X", + "53716": "AB887X", + "53717": "AB887X", + "53718": "AB887X", + "53719": "AB887X", + "53725": "AB887X", + "53726": "AB887X", + "53744": "AB887X", + "53774": "AB887X", + "53777": "AB887X", + "53778": "AB887X", + "53779": "AB887X", + "53782": "AB887X", + "53783": "AB887X", + "53784": "AB887X", + "53785": "AB887X", + "53786": "AB887X", + "53788": "AB887X", + "53789": "AB887X", + "53790": "AB887X", + "53791": "AB887X", + "53792": "AB887X", + "53793": "AB887X", + "53794": "AB887X", + "53801": "AB887X", + "53802": "AB887X", + "53803": "AB888X", + "53804": "AB888X", + "53805": "AB887X", + "53806": "AB888X", + "53807": "AB888X", + "53808": "AB888X", + "53809": "AB887X", + "53810": "AB888X", + "53811": "AB888X", + "53812": "AB888X", + "53813": "AB888X", + "53816": "AB887X", + "53817": "AB887X", + "53818": "AB887X", + "53820": "AB888X", + "53821": "AB889X", + "53824": "AB887X", + "53825": "AB887X", + "53826": "AB887X", + "53827": "AB887X", + "53901": "AB887X", + "53910": "AB887X", + "53911": "AB887X", + "53913": "AB887X", + "53916": "AB887X", + "53919": "AB887X", + "53920": "AB887X", + "53922": "AB887X", + "53923": "AB887X", + "53924": "AB887X", + "53925": "AB887X", + "53926": "AB887X", + "53927": "AB887X", + "53928": "AB887X", + "53929": "AB889X", + "53930": "AB887X", + "53931": "AB887X", + "53932": "AB887X", + "53933": "AB887X", + "53934": "AB887X", + "53935": "AB887X", + "53936": "AB887X", + "53937": "AB887X", + "53939": "AB887X", + "53940": "AB887X", + "53941": "AB887X", + "53942": "AB887X", + "53943": "AB887X", + "53944": "AB889X", + "53946": "AB887X", + "53947": "AB887X", + "53948": "AB889X", + "53949": "AB887X", + "53950": "AB889X", + "53951": "AB887X", + "53952": "AB889X", + "53953": "AB887X", + "53954": "AB887X", + "53955": "AB887X", + "53956": "AB887X", + "53957": "AB887X", + "53958": "AB887X", + "53959": "AB887X", + "53960": "AB887X", + "53961": "AB887X", + "53962": "AB889X", + "53963": "AB887X", + "53964": "AB887X", + "53965": "AB887X", + "53968": "AB889X", + "53969": "AB887X", + "54001": "AB889X", + "54002": "AB889X", + "54003": "AB889X", + "54004": "AB889X", + "54005": "AB889X", + "54006": "AB889X", + "54007": "AB889X", + "54009": "AB889X", + "54010": "AB889X", + "54011": "AB889X", + "54013": "AB889X", + "54014": "AB889X", + "54015": "AB889X", + "54016": "AB889X", + "54017": "AB889X", + "54020": "AB889X", + "54021": "AB889X", + "54022": "AB889X", + "54023": "AB889X", + "54024": "AB889X", + "54025": "AB889X", + "54026": "AB889X", + "54027": "AB889X", + "54028": "AB889X", + "54035": "AB887X", + "54074": "AB888X", + "54082": "AB889X", + "54101": "AB887X", + "54102": "AB887X", + "54103": "AB887X", + "54104": "AB887X", + "54106": "AB887X", + "54107": "AB887X", + "54110": "AB887X", + "54111": "AB887X", + "54112": "AB887X", + "54113": "AB887X", + "54114": "AB887X", + "54115": "AB887X", + "54119": "AB887X", + "54120": "AB887X", + "54121": "AB887X", + "54123": "AB887X", + "54124": "AB887X", + "54125": "AB887X", + "54126": "AB887X", + "54127": "AB887X", + "54128": "AB887X", + "54129": "AB887X", + "54130": "AB887X", + "54131": "AB887X", + "54135": "AB887X", + "54136": "AB887X", + "54137": "AB887X", + "54138": "AB887X", + "54139": "AB887X", + "54140": "AB887X", + "54141": "AB887X", + "54143": "AB887X", + "54149": "AB887X", + "54150": "AB887X", + "54151": "AB887X", + "54152": "AB887X", + "54153": "AB887X", + "54154": "AB887X", + "54155": "AB887X", + "54156": "AB887X", + "54157": "AB887X", + "54159": "AB887X", + "54160": "AB887X", + "54161": "AB887X", + "54162": "AB887X", + "54165": "AB887X", + "54166": "AB887X", + "54169": "AB887X", + "54170": "AB887X", + "54171": "AB887X", + "54173": "AB887X", + "54174": "AB887X", + "54175": "AB887X", + "54177": "AB887X", + "54180": "AB887X", + "54182": "AB887X", + "54201": "AB887X", + "54202": "AB887X", + "54204": "AB887X", + "54205": "AB887X", + "54207": "AB887X", + "54208": "AB887X", + "54209": "AB887X", + "54210": "AB887X", + "54211": "AB887X", + "54212": "AB887X", + "54213": "AB887X", + "54214": "AB887X", + "54215": "AB887X", + "54216": "AB887X", + "54217": "AB887X", + "54220": "AB887X", + "54221": "AB887X", + "54226": "AB887X", + "54227": "AB887X", + "54228": "AB887X", + "54229": "AB887X", + "54230": "AB887X", + "54232": "AB887X", + "54234": "AB887X", + "54235": "AB887X", + "54240": "AB887X", + "54241": "AB887X", + "54245": "AB887X", + "54246": "AB887X", + "54247": "AB887X", + "54301": "AB887X", + "54302": "AB887X", + "54303": "AB887X", + "54304": "AB887X", + "54305": "AB887X", + "54306": "AB887X", + "54307": "AB887X", + "54308": "AB887X", + "54311": "AB887X", + "54313": "AB887X", + "54324": "AB887X", + "54344": "AB887X", + "54401": "AB887X", + "54402": "AB887X", + "54403": "AB887X", + "54404": "AB887X", + "54405": "AB887X", + "54406": "AB887X", + "54407": "AB887X", + "54408": "AB887X", + "54409": "AB887X", + "54410": "AB887X", + "54411": "AB887X", + "54412": "AB887X", + "54413": "AB887X", + "54414": "AB887X", + "54415": "AB887X", + "54416": "AB887X", + "54417": "AB887X", + "54418": "AB887X", + "54420": "AB887X", + "54421": "AB887X", + "54422": "AB887X", + "54423": "AB887X", + "54424": "AB887X", + "54425": "AB887X", + "54426": "AB887X", + "54427": "AB887X", + "54428": "AB887X", + "54429": "AB887X", + "54430": "AB887X", + "54432": "AB887X", + "54433": "AB887X", + "54434": "AB887X", + "54435": "AB887X", + "54436": "AB887X", + "54437": "AB887X", + "54439": "AB887X", + "54440": "AB887X", + "54441": "AB887X", + "54442": "AB887X", + "54443": "AB887X", + "54446": "AB887X", + "54447": "AB887X", + "54448": "AB887X", + "54449": "AB887X", + "54450": "AB887X", + "54451": "AB887X", + "54452": "AB887X", + "54454": "AB887X", + "54455": "AB887X", + "54456": "AB887X", + "54457": "AB887X", + "54458": "AB887X", + "54459": "AB887X", + "54460": "AB887X", + "54462": "AB887X", + "54463": "AB887X", + "54464": "AB887X", + "54465": "AB889X", + "54466": "AB887X", + "54467": "AB887X", + "54469": "AB887X", + "54470": "AB887X", + "54471": "AB887X", + "54472": "AB887X", + "54473": "AB887X", + "54474": "AB887X", + "54475": "AB887X", + "54476": "AB887X", + "54479": "AB887X", + "54480": "AB887X", + "54481": "AB887X", + "54482": "AB887X", + "54484": "AB887X", + "54485": "AB887X", + "54486": "AB887X", + "54487": "AB887X", + "54488": "AB887X", + "54489": "AB887X", + "54490": "AB887X", + "54491": "AB887X", + "54492": "AB887X", + "54493": "AB889X", + "54494": "AB887X", + "54495": "AB887X", + "54498": "AB887X", + "54499": "AB887X", + "54501": "AB887X", + "54510": "AB889X", + "54511": "AB887X", + "54512": "AB887X", + "54513": "AB887X", + "54514": "AB889X", + "54515": "AB889X", + "54517": "AB889X", + "54519": "AB887X", + "54520": "AB887X", + "54521": "AB887X", + "54524": "AB887X", + "54525": "AB889X", + "54526": "AB889X", + "54527": "AB889X", + "54529": "AB887X", + "54530": "AB889X", + "54531": "AB887X", + "54532": "AB887X", + "54534": "AB889X", + "54536": "AB889X", + "54537": "AB889X", + "54538": "AB887X", + "54539": "AB887X", + "54540": "AB889X", + "54541": "AB887X", + "54542": "AB887X", + "54543": "AB887X", + "54545": "AB887X", + "54546": "AB889X", + "54547": "AB889X", + "54548": "AB887X", + "54550": "AB889X", + "54552": "AB889X", + "54553": "AB889X", + "54554": "AB889X", + "54555": "AB889X", + "54556": "AB887X", + "54557": "AB887X", + "54558": "AB887X", + "54559": "AB889X", + "54560": "AB887X", + "54561": "AB887X", + "54562": "AB887X", + "54563": "AB889X", + "54564": "AB887X", + "54565": "AB889X", + "54566": "AB887X", + "54568": "AB887X", + "54601": "AB889X", + "54602": "AB889X", + "54603": "AB889X", + "54610": "AB889X", + "54611": "AB889X", + "54612": "AB889X", + "54613": "AB887X", + "54614": "AB889X", + "54615": "AB889X", + "54616": "AB889X", + "54618": "AB889X", + "54619": "AB889X", + "54620": "AB889X", + "54621": "AB889X", + "54622": "AB889X", + "54623": "AB889X", + "54624": "AB889X", + "54625": "AB889X", + "54626": "AB887X", + "54627": "AB889X", + "54628": "AB889X", + "54629": "AB889X", + "54630": "AB889X", + "54631": "AB887X", + "54632": "AB889X", + "54634": "AB887X", + "54635": "AB889X", + "54636": "AB889X", + "54637": "AB889X", + "54638": "AB889X", + "54639": "AB889X", + "54640": "AB887X", + "54641": "AB889X", + "54642": "AB889X", + "54643": "AB889X", + "54644": "AB889X", + "54645": "AB887X", + "54646": "AB889X", + "54648": "AB889X", + "54649": "AB889X", + "54650": "AB889X", + "54651": "AB889X", + "54652": "AB889X", + "54653": "AB889X", + "54654": "AB887X", + "54655": "AB887X", + "54656": "AB889X", + "54657": "AB887X", + "54658": "AB889X", + "54659": "AB889X", + "54660": "AB889X", + "54661": "AB889X", + "54662": "AB889X", + "54664": "AB887X", + "54665": "AB889X", + "54666": "AB889X", + "54667": "AB889X", + "54669": "AB889X", + "54670": "AB889X", + "54678": "AB887X", + "54701": "AB889X", + "54702": "AB889X", + "54703": "AB889X", + "54720": "AB889X", + "54721": "AB889X", + "54722": "AB889X", + "54723": "AB889X", + "54724": "AB889X", + "54725": "AB889X", + "54726": "AB889X", + "54727": "AB889X", + "54728": "AB889X", + "54729": "AB889X", + "54730": "AB889X", + "54731": "AB889X", + "54732": "AB889X", + "54733": "AB889X", + "54734": "AB889X", + "54735": "AB889X", + "54736": "AB889X", + "54737": "AB889X", + "54738": "AB889X", + "54739": "AB889X", + "54740": "AB889X", + "54741": "AB889X", + "54742": "AB889X", + "54743": "AB889X", + "54745": "AB889X", + "54746": "AB887X", + "54747": "AB889X", + "54748": "AB889X", + "54749": "AB889X", + "54750": "AB889X", + "54751": "AB889X", + "54754": "AB889X", + "54755": "AB889X", + "54756": "AB889X", + "54757": "AB889X", + "54758": "AB889X", + "54759": "AB889X", + "54760": "AB889X", + "54761": "AB889X", + "54762": "AB889X", + "54763": "AB889X", + "54764": "AB889X", + "54765": "AB889X", + "54766": "AB889X", + "54767": "AB889X", + "54768": "AB889X", + "54769": "AB889X", + "54770": "AB889X", + "54771": "AB889X", + "54772": "AB889X", + "54773": "AB889X", + "54774": "AB889X", + "54801": "AB889X", + "54805": "AB889X", + "54806": "AB889X", + "54810": "AB889X", + "54812": "AB889X", + "54813": "AB889X", + "54814": "AB889X", + "54816": "AB889X", + "54817": "AB889X", + "54818": "AB889X", + "54819": "AB889X", + "54820": "AB889X", + "54821": "AB889X", + "54822": "AB889X", + "54824": "AB889X", + "54826": "AB889X", + "54827": "AB889X", + "54828": "AB889X", + "54829": "AB889X", + "54830": "AB889X", + "54832": "AB889X", + "54834": "AB889X", + "54835": "AB889X", + "54836": "AB889X", + "54837": "AB889X", + "54838": "AB889X", + "54839": "AB889X", + "54840": "AB889X", + "54841": "AB889X", + "54842": "AB889X", + "54843": "AB889X", + "54844": "AB889X", + "54845": "AB889X", + "54846": "AB889X", + "54847": "AB889X", + "54848": "AB889X", + "54849": "AB889X", + "54850": "AB889X", + "54853": "AB889X", + "54854": "AB889X", + "54855": "AB889X", + "54856": "AB889X", + "54857": "AB889X", + "54858": "AB889X", + "54859": "AB889X", + "54861": "AB889X", + "54862": "AB889X", + "54864": "AB889X", + "54865": "AB889X", + "54867": "AB889X", + "54868": "AB889X", + "54870": "AB889X", + "54871": "AB889X", + "54872": "AB889X", + "54873": "AB889X", + "54874": "AB889X", + "54875": "AB889X", + "54876": "AB889X", + "54880": "AB889X", + "54888": "AB889X", + "54889": "AB889X", + "54890": "AB889X", + "54891": "AB889X", + "54893": "AB889X", + "54895": "AB889X", + "54896": "AB889X", + "54901": "AB889X", + "54902": "AB887X", + "54903": "AB887X", + "54904": "AB887X", + "54906": "AB887X", + "54909": "AB887X", + "54911": "AB887X", + "54912": "AB887X", + "54913": "AB887X", + "54914": "AB887X", + "54915": "AB887X", + "54919": "AB887X", + "54921": "AB887X", + "54922": "AB887X", + "54923": "AB887X", + "54926": "AB887X", + "54927": "AB887X", + "54928": "AB887X", + "54929": "AB887X", + "54930": "AB887X", + "54931": "AB887X", + "54932": "AB887X", + "54933": "AB887X", + "54934": "AB887X", + "54935": "AB887X", + "54936": "AB887X", + "54937": "AB887X", + "54940": "AB887X", + "54941": "AB887X", + "54942": "AB887X", + "54943": "AB887X", + "54944": "AB887X", + "54945": "AB887X", + "54946": "AB887X", + "54947": "AB887X", + "54948": "AB887X", + "54949": "AB887X", + "54950": "AB887X", + "54952": "AB887X", + "54956": "AB887X", + "54957": "AB887X", + "54960": "AB887X", + "54961": "AB887X", + "54962": "AB887X", + "54963": "AB887X", + "54964": "AB887X", + "54965": "AB887X", + "54966": "AB887X", + "54967": "AB887X", + "54968": "AB887X", + "54969": "AB887X", + "54970": "AB887X", + "54971": "AB887X", + "54974": "AB887X", + "54976": "AB887X", + "54977": "AB887X", + "54978": "AB887X", + "54979": "AB887X", + "54980": "AB887X", + "54981": "AB889X", + "54982": "AB887X", + "54983": "AB887X", + "54984": "AB887X", + "54985": "AB887X", + "54986": "AB887X", + "54990": "AB887X", + "55001": "AB889X", + "55002": "AB889X", + "55003": "AB889X", + "55005": "AB889X", + "55006": "AB889X", + "55007": "AB889X", + "55008": "AB889X", + "55009": "AB889X", + "55010": "AB889X", + "55011": "AB889X", + "55012": "AB889X", + "55013": "AB889X", + "55014": "AB889X", + "55016": "AB889X", + "55017": "AB889X", + "55018": "AB889X", + "55019": "AB889X", + "55020": "AB889X", + "55021": "AB889X", + "55024": "AB889X", + "55025": "AB889X", + "55026": "AB889X", + "55027": "AB889X", + "55029": "AB889X", + "55030": "AB889X", + "55031": "AB889X", + "55032": "AB889X", + "55033": "AB889X", + "55036": "AB889X", + "55037": "AB889X", + "55038": "AB889X", + "55040": "AB889X", + "55041": "AB889X", + "55042": "AB889X", + "55043": "AB889X", + "55044": "AB889X", + "55045": "AB889X", + "55046": "AB889X", + "55047": "AB889X", + "55049": "AB889X", + "55051": "AB889X", + "55052": "AB889X", + "55053": "AB889X", + "55054": "AB889X", + "55055": "AB889X", + "55056": "AB889X", + "55057": "AB889X", + "55060": "AB889X", + "55063": "AB889X", + "55065": "AB889X", + "55066": "AB889X", + "55067": "AB889X", + "55068": "AB889X", + "55069": "AB889X", + "55070": "AB889X", + "55071": "AB889X", + "55072": "AB889X", + "55073": "AB889X", + "55074": "AB889X", + "55075": "AB889X", + "55076": "AB889X", + "55077": "AB889X", + "55078": "AB889X", + "55079": "AB889X", + "55080": "AB889X", + "55082": "AB889X", + "55083": "AB889X", + "55084": "AB889X", + "55085": "AB889X", + "55087": "AB889X", + "55088": "AB889X", + "55089": "AB889X", + "55090": "AB889X", + "55092": "AB889X", + "55101": "AB889X", + "55102": "AB889X", + "55103": "AB889X", + "55104": "AB889X", + "55105": "AB889X", + "55106": "AB889X", + "55107": "AB889X", + "55108": "AB889X", + "55109": "AB889X", + "55110": "AB889X", + "55111": "AB889X", + "55112": "AB889X", + "55113": "AB889X", + "55114": "AB889X", + "55115": "AB889X", + "55116": "AB889X", + "55117": "AB889X", + "55118": "AB889X", + "55119": "AB889X", + "55120": "AB889X", + "55121": "AB889X", + "55122": "AB889X", + "55123": "AB889X", + "55124": "AB889X", + "55125": "AB889X", + "55126": "AB889X", + "55127": "AB889X", + "55128": "AB889X", + "55129": "AB889X", + "55130": "AB889X", + "55133": "AB889X", + "55144": "AB889X", + "55145": "AB889X", + "55146": "AB889X", + "55150": "AB889X", + "55155": "AB889X", + "55161": "AB889X", + "55164": "AB889X", + "55165": "AB889X", + "55166": "AB889X", + "55168": "AB889X", + "55169": "AB889X", + "55170": "AB889X", + "55171": "AB889X", + "55172": "AB889X", + "55175": "AB889X", + "55177": "AB889X", + "55187": "AB889X", + "55188": "AB889X", + "55191": "AB889X", + "55301": "AB889X", + "55302": "AB889X", + "55303": "AB889X", + "55304": "AB889X", + "55305": "AB889X", + "55306": "AB889X", + "55307": "AB889X", + "55308": "AB889X", + "55309": "AB889X", + "55310": "AB889X", + "55311": "AB889X", + "55312": "AB889X", + "55313": "AB889X", + "55314": "AB889X", + "55315": "AB889X", + "55316": "AB889X", + "55317": "AB889X", + "55318": "AB889X", + "55319": "AB889X", + "55320": "AB889X", + "55321": "AB889X", + "55322": "AB889X", + "55323": "AB889X", + "55324": "AB889X", + "55325": "AB889X", + "55327": "AB889X", + "55328": "AB889X", + "55329": "AB889X", + "55330": "AB889X", + "55331": "AB889X", + "55332": "AB889X", + "55333": "AB889X", + "55334": "AB889X", + "55335": "AB889X", + "55336": "AB889X", + "55337": "AB889X", + "55338": "AB889X", + "55339": "AB889X", + "55340": "AB889X", + "55341": "AB889X", + "55342": "AB889X", + "55343": "AB889X", + "55344": "AB889X", + "55345": "AB889X", + "55346": "AB889X", + "55347": "AB889X", + "55348": "AB889X", + "55349": "AB889X", + "55350": "AB889X", + "55352": "AB889X", + "55353": "AB889X", + "55354": "AB889X", + "55355": "AB889X", + "55356": "AB889X", + "55357": "AB889X", + "55358": "AB889X", + "55359": "AB889X", + "55360": "AB889X", + "55361": "AB889X", + "55362": "AB889X", + "55363": "AB889X", + "55364": "AB889X", + "55365": "AB889X", + "55366": "AB889X", + "55367": "AB889X", + "55368": "AB889X", + "55369": "AB889X", + "55370": "AB889X", + "55371": "AB889X", + "55372": "AB889X", + "55373": "AB889X", + "55374": "AB889X", + "55375": "AB889X", + "55376": "AB889X", + "55377": "AB889X", + "55378": "AB889X", + "55379": "AB889X", + "55380": "AB889X", + "55381": "AB889X", + "55382": "AB889X", + "55383": "AB889X", + "55384": "AB889X", + "55385": "AB889X", + "55386": "AB889X", + "55387": "AB889X", + "55388": "AB889X", + "55389": "AB889X", + "55390": "AB889X", + "55391": "AB889X", + "55392": "AB889X", + "55393": "AB889X", + "55394": "AB889X", + "55395": "AB889X", + "55396": "AB889X", + "55397": "AB889X", + "55398": "AB889X", + "55399": "AB889X", + "55401": "AB889X", + "55402": "AB889X", + "55403": "AB889X", + "55404": "AB889X", + "55405": "AB889X", + "55406": "AB889X", + "55407": "AB889X", + "55408": "AB889X", + "55409": "AB889X", + "55410": "AB889X", + "55411": "AB889X", + "55412": "AB889X", + "55413": "AB889X", + "55414": "AB889X", + "55415": "AB889X", + "55416": "AB889X", + "55417": "AB889X", + "55418": "AB889X", + "55419": "AB889X", + "55420": "AB889X", + "55421": "AB889X", + "55422": "AB889X", + "55423": "AB889X", + "55424": "AB889X", + "55425": "AB889X", + "55426": "AB889X", + "55427": "AB889X", + "55428": "AB889X", + "55429": "AB889X", + "55430": "AB889X", + "55431": "AB889X", + "55432": "AB889X", + "55433": "AB889X", + "55434": "AB889X", + "55435": "AB889X", + "55436": "AB889X", + "55437": "AB889X", + "55438": "AB889X", + "55439": "AB889X", + "55440": "AB889X", + "55441": "AB889X", + "55442": "AB889X", + "55443": "AB889X", + "55444": "AB889X", + "55445": "AB889X", + "55446": "AB889X", + "55447": "AB889X", + "55448": "AB889X", + "55449": "AB889X", + "55450": "AB889X", + "55454": "AB889X", + "55455": "AB889X", + "55458": "AB889X", + "55459": "AB889X", + "55460": "AB889X", + "55467": "AB889X", + "55468": "AB889X", + "55470": "AB889X", + "55472": "AB889X", + "55473": "AB889X", + "55474": "AB889X", + "55478": "AB889X", + "55479": "AB889X", + "55480": "AB889X", + "55483": "AB889X", + "55484": "AB889X", + "55485": "AB889X", + "55486": "AB889X", + "55487": "AB889X", + "55488": "AB889X", + "55550": "AB889X", + "55551": "AB889X", + "55552": "AB889X", + "55553": "AB889X", + "55554": "AB889X", + "55555": "AB889X", + "55556": "AB889X", + "55557": "AB889X", + "55558": "AB889X", + "55559": "AB889X", + "55560": "AB889X", + "55561": "AB889X", + "55562": "AB889X", + "55563": "AB889X", + "55564": "AB889X", + "55565": "AB889X", + "55566": "AB889X", + "55567": "AB889X", + "55568": "AB889X", + "55569": "AB889X", + "55570": "AB889X", + "55571": "AB889X", + "55572": "AB889X", + "55573": "AB889X", + "55574": "AB889X", + "55575": "AB889X", + "55576": "AB889X", + "55577": "AB889X", + "55578": "AB889X", + "55579": "AB889X", + "55580": "AB889X", + "55581": "AB889X", + "55582": "AB889X", + "55583": "AB889X", + "55584": "AB889X", + "55585": "AB889X", + "55586": "AB889X", + "55587": "AB889X", + "55588": "AB889X", + "55589": "AB889X", + "55590": "AB889X", + "55591": "AB889X", + "55592": "AB889X", + "55593": "AB889X", + "55594": "AB889X", + "55595": "AB889X", + "55596": "AB889X", + "55597": "AB889X", + "55598": "AB889X", + "55599": "AB889X", + "55601": "AB889X", + "55602": "AB889X", + "55603": "AB889X", + "55604": "AB889X", + "55605": "AB889X", + "55606": "AB889X", + "55607": "AB889X", + "55609": "AB889X", + "55612": "AB889X", + "55613": "AB889X", + "55614": "AB889X", + "55615": "AB889X", + "55616": "AB889X", + "55659": "AB889X", + "55701": "AB889X", + "55702": "AB889X", + "55703": "AB889X", + "55704": "AB889X", + "55705": "AB889X", + "55706": "AB889X", + "55707": "AB889X", + "55708": "AB889X", + "55709": "AB889X", + "55710": "AB889X", + "55711": "AB889X", + "55712": "AB889X", + "55713": "AB889X", + "55716": "AB889X", + "55717": "AB889X", + "55718": "AB889X", + "55719": "AB889X", + "55720": "AB889X", + "55721": "AB889X", + "55722": "AB889X", + "55723": "AB889X", + "55724": "AB889X", + "55725": "AB889X", + "55726": "AB889X", + "55729": "AB889X", + "55730": "AB889X", + "55731": "AB889X", + "55732": "AB889X", + "55733": "AB889X", + "55734": "AB889X", + "55735": "AB889X", + "55736": "AB889X", + "55738": "AB889X", + "55741": "AB889X", + "55742": "AB889X", + "55744": "AB889X", + "55745": "AB889X", + "55746": "AB889X", + "55747": "AB889X", + "55748": "AB889X", + "55749": "AB889X", + "55750": "AB889X", + "55751": "AB889X", + "55752": "AB889X", + "55753": "AB889X", + "55756": "AB889X", + "55757": "AB889X", + "55758": "AB889X", + "55760": "AB889X", + "55763": "AB889X", + "55764": "AB889X", + "55765": "AB889X", + "55766": "AB889X", + "55767": "AB889X", + "55768": "AB889X", + "55769": "AB889X", + "55771": "AB889X", + "55772": "AB889X", + "55773": "AB889X", + "55775": "AB889X", + "55777": "AB889X", + "55779": "AB889X", + "55780": "AB889X", + "55781": "AB889X", + "55782": "AB889X", + "55783": "AB889X", + "55784": "AB889X", + "55785": "AB889X", + "55786": "AB889X", + "55787": "AB889X", + "55790": "AB889X", + "55791": "AB889X", + "55792": "AB889X", + "55793": "AB889X", + "55795": "AB889X", + "55796": "AB889X", + "55797": "AB889X", + "55798": "AB889X", + "55801": "AB889X", + "55802": "AB889X", + "55803": "AB889X", + "55804": "AB889X", + "55805": "AB889X", + "55806": "AB889X", + "55807": "AB889X", + "55808": "AB889X", + "55810": "AB889X", + "55811": "AB889X", + "55812": "AB889X", + "55814": "AB889X", + "55815": "AB889X", + "55816": "AB889X", + "55880": "AB889X", + "55901": "AB889X", + "55902": "AB889X", + "55903": "AB889X", + "55904": "AB889X", + "55905": "AB889X", + "55906": "AB889X", + "55909": "AB889X", + "55910": "AB889X", + "55912": "AB889X", + "55917": "AB889X", + "55918": "AB889X", + "55919": "AB889X", + "55920": "AB889X", + "55921": "AB889X", + "55922": "AB889X", + "55923": "AB889X", + "55924": "AB889X", + "55925": "AB889X", + "55926": "AB889X", + "55927": "AB889X", + "55929": "AB889X", + "55931": "AB889X", + "55932": "AB889X", + "55933": "AB889X", + "55934": "AB889X", + "55935": "AB889X", + "55936": "AB889X", + "55939": "AB889X", + "55940": "AB889X", + "55941": "AB889X", + "55942": "AB889X", + "55943": "AB889X", + "55944": "AB889X", + "55945": "AB889X", + "55946": "AB889X", + "55947": "AB889X", + "55949": "AB889X", + "55950": "AB889X", + "55951": "AB889X", + "55952": "AB889X", + "55953": "AB889X", + "55954": "AB889X", + "55955": "AB889X", + "55956": "AB889X", + "55957": "AB889X", + "55959": "AB889X", + "55960": "AB889X", + "55961": "AB889X", + "55962": "AB889X", + "55963": "AB889X", + "55964": "AB889X", + "55965": "AB889X", + "55967": "AB889X", + "55968": "AB889X", + "55969": "AB889X", + "55970": "AB889X", + "55971": "AB889X", + "55972": "AB889X", + "55973": "AB889X", + "55974": "AB889X", + "55975": "AB889X", + "55976": "AB889X", + "55977": "AB889X", + "55979": "AB889X", + "55981": "AB889X", + "55982": "AB889X", + "55983": "AB889X", + "55985": "AB889X", + "55987": "AB889X", + "55988": "AB889X", + "55990": "AB889X", + "55991": "AB889X", + "55992": "AB889X", + "56001": "AB889X", + "56002": "AB889X", + "56003": "AB889X", + "56006": "AB889X", + "56007": "AB889X", + "56009": "AB889X", + "56010": "AB889X", + "56011": "AB889X", + "56013": "AB889X", + "56014": "AB889X", + "56016": "AB889X", + "56017": "AB889X", + "56019": "AB889X", + "56020": "AB889X", + "56021": "AB889X", + "56022": "AB889X", + "56023": "AB889X", + "56024": "AB889X", + "56025": "AB889X", + "56026": "AB889X", + "56027": "AB889X", + "56028": "AB889X", + "56029": "AB889X", + "56030": "AB889X", + "56031": "AB889X", + "56032": "AB889X", + "56033": "AB889X", + "56034": "AB889X", + "56035": "AB889X", + "56036": "AB889X", + "56037": "AB889X", + "56039": "AB889X", + "56041": "AB889X", + "56042": "AB889X", + "56043": "AB889X", + "56044": "AB889X", + "56045": "AB889X", + "56046": "AB889X", + "56047": "AB889X", + "56048": "AB889X", + "56050": "AB889X", + "56051": "AB889X", + "56052": "AB889X", + "56054": "AB889X", + "56055": "AB889X", + "56056": "AB889X", + "56057": "AB889X", + "56058": "AB889X", + "56060": "AB889X", + "56062": "AB889X", + "56063": "AB889X", + "56065": "AB889X", + "56068": "AB889X", + "56069": "AB889X", + "56071": "AB889X", + "56072": "AB889X", + "56073": "AB889X", + "56074": "AB889X", + "56075": "AB889X", + "56078": "AB889X", + "56080": "AB889X", + "56081": "AB889X", + "56082": "AB889X", + "56083": "AB889X", + "56084": "AB889X", + "56085": "AB889X", + "56087": "AB889X", + "56088": "AB889X", + "56089": "AB889X", + "56090": "AB889X", + "56091": "AB889X", + "56093": "AB889X", + "56096": "AB889X", + "56097": "AB889X", + "56098": "AB889X", + "56101": "AB889X", + "56110": "AB891X", + "56111": "AB889X", + "56113": "AB889X", + "56114": "AB889X", + "56115": "AB889X", + "56116": "AB889X", + "56117": "AB891X", + "56118": "AB889X", + "56119": "AB891X", + "56120": "AB889X", + "56121": "AB889X", + "56122": "AB889X", + "56123": "AB889X", + "56125": "AB889X", + "56127": "AB889X", + "56128": "AB889X", + "56129": "AB891X", + "56131": "AB889X", + "56132": "AB889X", + "56134": "AB889X", + "56136": "AB891X", + "56137": "AB889X", + "56138": "AB889X", + "56139": "AB889X", + "56140": "AB889X", + "56141": "AB889X", + "56142": "AB891X", + "56143": "AB889X", + "56144": "AB889X", + "56145": "AB889X", + "56146": "AB891X", + "56147": "AB889X", + "56149": "AB891X", + "56150": "AB889X", + "56151": "AB889X", + "56152": "AB889X", + "56153": "AB891X", + "56155": "AB891X", + "56156": "AB889X", + "56157": "AB889X", + "56158": "AB889X", + "56159": "AB889X", + "56160": "AB889X", + "56161": "AB889X", + "56162": "AB889X", + "56164": "AB889X", + "56165": "AB891X", + "56166": "AB889X", + "56167": "AB891X", + "56168": "AB891X", + "56169": "AB891X", + "56170": "AB889X", + "56171": "AB889X", + "56172": "AB889X", + "56173": "AB889X", + "56174": "AB889X", + "56175": "AB889X", + "56176": "AB889X", + "56177": "AB889X", + "56178": "AB891X", + "56180": "AB889X", + "56181": "AB889X", + "56183": "AB889X", + "56185": "AB891X", + "56186": "AB889X", + "56187": "AB891X", + "56201": "AB889X", + "56207": "AB889X", + "56208": "AB889X", + "56209": "AB889X", + "56210": "AB889X", + "56211": "AB889X", + "56212": "AB889X", + "56214": "AB889X", + "56215": "AB889X", + "56216": "AB889X", + "56218": "AB889X", + "56219": "AB889X", + "56220": "AB889X", + "56221": "AB889X", + "56222": "AB889X", + "56223": "AB889X", + "56224": "AB889X", + "56225": "AB889X", + "56226": "AB889X", + "56227": "AB889X", + "56228": "AB889X", + "56229": "AB889X", + "56230": "AB889X", + "56231": "AB889X", + "56232": "AB889X", + "56235": "AB889X", + "56236": "AB889X", + "56237": "AB889X", + "56239": "AB889X", + "56240": "AB889X", + "56241": "AB889X", + "56243": "AB889X", + "56244": "AB889X", + "56245": "AB889X", + "56248": "AB889X", + "56249": "AB889X", + "56251": "AB889X", + "56252": "AB889X", + "56253": "AB889X", + "56254": "AB889X", + "56255": "AB889X", + "56256": "AB889X", + "56257": "AB889X", + "56258": "AB889X", + "56260": "AB889X", + "56262": "AB889X", + "56263": "AB889X", + "56264": "AB889X", + "56265": "AB889X", + "56266": "AB889X", + "56267": "AB889X", + "56268": "AB889X", + "56270": "AB889X", + "56271": "AB889X", + "56272": "AB889X", + "56273": "AB889X", + "56274": "AB889X", + "56276": "AB889X", + "56277": "AB889X", + "56278": "AB889X", + "56279": "AB889X", + "56280": "AB889X", + "56281": "AB889X", + "56282": "AB889X", + "56283": "AB889X", + "56284": "AB889X", + "56285": "AB889X", + "56287": "AB889X", + "56288": "AB889X", + "56289": "AB889X", + "56291": "AB889X", + "56292": "AB889X", + "56293": "AB889X", + "56294": "AB889X", + "56295": "AB889X", + "56296": "AB889X", + "56297": "AB889X", + "56301": "AB889X", + "56302": "AB889X", + "56303": "AB889X", + "56304": "AB889X", + "56307": "AB889X", + "56308": "AB889X", + "56309": "AB889X", + "56310": "AB889X", + "56311": "AB889X", + "56312": "AB889X", + "56313": "AB889X", + "56314": "AB889X", + "56315": "AB889X", + "56316": "AB889X", + "56317": "AB889X", + "56318": "AB889X", + "56319": "AB889X", + "56320": "AB889X", + "56321": "AB889X", + "56323": "AB889X", + "56324": "AB889X", + "56325": "AB889X", + "56326": "AB889X", + "56327": "AB889X", + "56328": "AB889X", + "56329": "AB889X", + "56330": "AB889X", + "56331": "AB889X", + "56332": "AB889X", + "56333": "AB889X", + "56334": "AB889X", + "56335": "AB889X", + "56336": "AB889X", + "56338": "AB889X", + "56339": "AB889X", + "56340": "AB889X", + "56341": "AB889X", + "56342": "AB889X", + "56343": "AB889X", + "56344": "AB889X", + "56345": "AB889X", + "56347": "AB889X", + "56349": "AB889X", + "56350": "AB889X", + "56352": "AB889X", + "56353": "AB889X", + "56354": "AB889X", + "56355": "AB889X", + "56356": "AB889X", + "56357": "AB889X", + "56358": "AB889X", + "56359": "AB889X", + "56360": "AB889X", + "56361": "AB889X", + "56362": "AB889X", + "56363": "AB889X", + "56364": "AB889X", + "56367": "AB889X", + "56368": "AB889X", + "56369": "AB889X", + "56371": "AB889X", + "56372": "AB889X", + "56373": "AB889X", + "56374": "AB889X", + "56375": "AB889X", + "56376": "AB889X", + "56377": "AB889X", + "56378": "AB889X", + "56379": "AB889X", + "56381": "AB889X", + "56382": "AB889X", + "56384": "AB889X", + "56385": "AB889X", + "56386": "AB889X", + "56387": "AB889X", + "56388": "AB889X", + "56389": "AB889X", + "56393": "AB889X", + "56395": "AB889X", + "56396": "AB889X", + "56397": "AB889X", + "56398": "AB889X", + "56399": "AB889X", + "56401": "AB889X", + "56425": "AB889X", + "56430": "AB889X", + "56431": "AB889X", + "56433": "AB889X", + "56434": "AB889X", + "56435": "AB889X", + "56436": "AB889X", + "56437": "AB889X", + "56438": "AB889X", + "56440": "AB889X", + "56441": "AB889X", + "56442": "AB889X", + "56443": "AB889X", + "56444": "AB889X", + "56446": "AB889X", + "56447": "AB889X", + "56448": "AB889X", + "56449": "AB889X", + "56450": "AB889X", + "56452": "AB889X", + "56453": "AB889X", + "56455": "AB889X", + "56456": "AB889X", + "56458": "AB889X", + "56459": "AB889X", + "56461": "AB889X", + "56464": "AB889X", + "56465": "AB889X", + "56466": "AB889X", + "56467": "AB889X", + "56468": "AB889X", + "56469": "AB889X", + "56470": "AB889X", + "56472": "AB889X", + "56473": "AB889X", + "56474": "AB889X", + "56475": "AB889X", + "56477": "AB889X", + "56478": "AB889X", + "56479": "AB889X", + "56481": "AB889X", + "56482": "AB889X", + "56484": "AB889X", + "56501": "AB889X", + "56502": "AB889X", + "56510": "AB889X", + "56511": "AB889X", + "56514": "AB889X", + "56515": "AB889X", + "56516": "AB889X", + "56517": "AB889X", + "56518": "AB889X", + "56519": "AB889X", + "56520": "AB889X", + "56521": "AB889X", + "56522": "AB889X", + "56523": "AB889X", + "56524": "AB889X", + "56525": "AB889X", + "56527": "AB889X", + "56528": "AB889X", + "56529": "AB889X", + "56531": "AB889X", + "56533": "AB889X", + "56534": "AB889X", + "56535": "AB889X", + "56536": "AB889X", + "56537": "AB889X", + "56538": "AB889X", + "56540": "AB889X", + "56541": "AB889X", + "56542": "AB889X", + "56543": "AB889X", + "56544": "AB889X", + "56545": "AB889X", + "56546": "AB889X", + "56547": "AB889X", + "56548": "AB889X", + "56549": "AB889X", + "56550": "AB889X", + "56551": "AB889X", + "56552": "AB889X", + "56553": "AB889X", + "56554": "AB889X", + "56556": "AB889X", + "56557": "AB889X", + "56560": "AB889X", + "56561": "AB889X", + "56562": "AB889X", + "56563": "AB889X", + "56565": "AB889X", + "56566": "AB889X", + "56567": "AB889X", + "56568": "AB889X", + "56569": "AB889X", + "56570": "AB889X", + "56571": "AB889X", + "56572": "AB889X", + "56573": "AB889X", + "56574": "AB889X", + "56575": "AB889X", + "56576": "AB889X", + "56577": "AB889X", + "56578": "AB889X", + "56579": "AB889X", + "56580": "AB889X", + "56581": "AB889X", + "56583": "AB889X", + "56584": "AB889X", + "56585": "AB889X", + "56586": "AB889X", + "56587": "AB889X", + "56588": "AB889X", + "56589": "AB889X", + "56590": "AB889X", + "56591": "AB889X", + "56592": "AB889X", + "56593": "AB889X", + "56594": "AB889X", + "56601": "AB889X", + "56619": "AB889X", + "56621": "AB889X", + "56623": "AB889X", + "56626": "AB889X", + "56627": "AB889X", + "56628": "AB889X", + "56629": "AB889X", + "56630": "AB889X", + "56631": "AB889X", + "56633": "AB889X", + "56634": "AB889X", + "56636": "AB889X", + "56637": "AB889X", + "56639": "AB889X", + "56641": "AB889X", + "56644": "AB889X", + "56646": "AB889X", + "56647": "AB889X", + "56649": "AB889X", + "56650": "AB889X", + "56651": "AB889X", + "56652": "AB889X", + "56653": "AB889X", + "56654": "AB889X", + "56655": "AB889X", + "56657": "AB889X", + "56658": "AB889X", + "56659": "AB889X", + "56660": "AB889X", + "56661": "AB889X", + "56662": "AB889X", + "56663": "AB889X", + "56666": "AB889X", + "56667": "AB889X", + "56668": "AB889X", + "56669": "AB889X", + "56670": "AB889X", + "56671": "AB889X", + "56672": "AB889X", + "56673": "AB889X", + "56676": "AB889X", + "56678": "AB889X", + "56679": "AB889X", + "56680": "AB889X", + "56681": "AB889X", + "56682": "AB889X", + "56683": "AB889X", + "56684": "AB889X", + "56685": "AB889X", + "56686": "AB889X", + "56687": "AB889X", + "56688": "AB889X", + "56701": "AB889X", + "56710": "AB889X", + "56711": "AB889X", + "56712": "AB889X", + "56713": "AB889X", + "56714": "AB889X", + "56715": "AB889X", + "56716": "AB889X", + "56720": "AB889X", + "56721": "AB889X", + "56722": "AB889X", + "56723": "AB889X", + "56724": "AB889X", + "56725": "AB889X", + "56726": "AB889X", + "56727": "AB889X", + "56728": "AB889X", + "56729": "AB889X", + "56731": "AB889X", + "56732": "AB889X", + "56733": "AB889X", + "56734": "AB889X", + "56735": "AB889X", + "56736": "AB889X", + "56737": "AB889X", + "56738": "AB889X", + "56740": "AB889X", + "56741": "AB889X", + "56742": "AB889X", + "56744": "AB889X", + "56748": "AB889X", + "56750": "AB889X", + "56751": "AB889X", + "56754": "AB889X", + "56755": "AB889X", + "56756": "AB889X", + "56757": "AB889X", + "56758": "AB889X", + "56759": "AB889X", + "56760": "AB889X", + "56761": "AB889X", + "56762": "AB889X", + "56763": "AB889X", + "57001": "AB891X", + "57002": "AB891X", + "57003": "AB891X", + "57004": "AB891X", + "57005": "AB891X", + "57006": "AB891X", + "57007": "AB891X", + "57010": "AB891X", + "57012": "AB891X", + "57013": "AB891X", + "57014": "AB891X", + "57015": "AB891X", + "57016": "AB891X", + "57017": "AB891X", + "57018": "AB891X", + "57020": "AB891X", + "57021": "AB891X", + "57022": "AB891X", + "57024": "AB891X", + "57025": "AB891X", + "57026": "AB891X", + "57027": "AB891X", + "57028": "AB891X", + "57029": "AB891X", + "57030": "AB891X", + "57031": "AB891X", + "57032": "AB891X", + "57033": "AB891X", + "57034": "AB891X", + "57035": "AB891X", + "57036": "AB891X", + "57037": "AB891X", + "57038": "AB891X", + "57039": "AB891X", + "57040": "AB891X", + "57041": "AB891X", + "57042": "AB891X", + "57043": "AB891X", + "57045": "AB891X", + "57046": "AB891X", + "57047": "AB891X", + "57048": "AB891X", + "57049": "AB891X", + "57050": "AB891X", + "57051": "AB891X", + "57052": "AB891X", + "57053": "AB891X", + "57054": "AB891X", + "57055": "AB891X", + "57056": "AB891X", + "57057": "AB891X", + "57058": "AB891X", + "57059": "AB891X", + "57061": "AB891X", + "57062": "AB891X", + "57063": "AB891X", + "57064": "AB891X", + "57065": "AB891X", + "57066": "AB891X", + "57067": "AB891X", + "57068": "AB891X", + "57069": "AB891X", + "57070": "AB891X", + "57071": "AB891X", + "57072": "AB891X", + "57073": "AB891X", + "57075": "AB891X", + "57076": "AB891X", + "57077": "AB891X", + "57078": "AB891X", + "57079": "AB891X", + "57101": "AB891X", + "57103": "AB891X", + "57104": "AB891X", + "57105": "AB891X", + "57106": "AB891X", + "57107": "AB891X", + "57108": "AB891X", + "57109": "AB891X", + "57110": "AB891X", + "57117": "AB891X", + "57118": "AB891X", + "57186": "AB891X", + "57188": "AB891X", + "57189": "AB891X", + "57192": "AB891X", + "57193": "AB891X", + "57194": "AB891X", + "57195": "AB891X", + "57196": "AB891X", + "57197": "AB891X", + "57198": "AB891X", + "57201": "AB891X", + "57212": "AB891X", + "57213": "AB891X", + "57214": "AB891X", + "57216": "AB891X", + "57217": "AB891X", + "57218": "AB891X", + "57219": "AB891X", + "57220": "AB891X", + "57221": "AB891X", + "57223": "AB891X", + "57224": "AB889X", + "57225": "AB891X", + "57226": "AB891X", + "57227": "AB889X", + "57231": "AB891X", + "57232": "AB891X", + "57233": "AB891X", + "57234": "AB891X", + "57235": "AB891X", + "57236": "AB891X", + "57237": "AB891X", + "57238": "AB891X", + "57239": "AB891X", + "57241": "AB891X", + "57242": "AB891X", + "57243": "AB891X", + "57245": "AB891X", + "57246": "AB891X", + "57247": "AB891X", + "57248": "AB891X", + "57249": "AB891X", + "57251": "AB891X", + "57252": "AB891X", + "57253": "AB891X", + "57255": "AB889X", + "57256": "AB889X", + "57257": "AB889X", + "57258": "AB891X", + "57259": "AB891X", + "57260": "AB889X", + "57261": "AB891X", + "57262": "AB889X", + "57263": "AB891X", + "57264": "AB891X", + "57265": "AB891X", + "57266": "AB889X", + "57268": "AB891X", + "57269": "AB891X", + "57270": "AB891X", + "57271": "AB891X", + "57272": "AB891X", + "57273": "AB891X", + "57274": "AB891X", + "57276": "AB891X", + "57278": "AB891X", + "57279": "AB889X", + "57301": "AB891X", + "57311": "AB891X", + "57312": "AB891X", + "57313": "AB891X", + "57314": "AB891X", + "57315": "AB891X", + "57317": "AB891X", + "57319": "AB891X", + "57321": "AB891X", + "57322": "AB891X", + "57323": "AB891X", + "57324": "AB891X", + "57325": "AB891X", + "57326": "AB891X", + "57328": "AB891X", + "57329": "AB891X", + "57330": "AB891X", + "57331": "AB891X", + "57332": "AB891X", + "57334": "AB891X", + "57335": "AB891X", + "57337": "AB891X", + "57339": "AB891X", + "57340": "AB891X", + "57341": "AB891X", + "57342": "AB891X", + "57344": "AB891X", + "57345": "AB891X", + "57346": "AB891X", + "57348": "AB891X", + "57349": "AB891X", + "57350": "AB891X", + "57353": "AB891X", + "57354": "AB891X", + "57355": "AB891X", + "57356": "AB891X", + "57358": "AB891X", + "57359": "AB891X", + "57361": "AB891X", + "57362": "AB891X", + "57363": "AB891X", + "57364": "AB891X", + "57365": "AB891X", + "57366": "AB891X", + "57367": "AB891X", + "57368": "AB891X", + "57369": "AB891X", + "57370": "AB891X", + "57371": "AB891X", + "57373": "AB891X", + "57374": "AB891X", + "57375": "AB891X", + "57376": "AB891X", + "57379": "AB891X", + "57380": "AB891X", + "57381": "AB891X", + "57382": "AB891X", + "57383": "AB891X", + "57384": "AB891X", + "57385": "AB891X", + "57386": "AB891X", + "57399": "AB891X", + "57401": "AB891X", + "57402": "AB891X", + "57420": "AB891X", + "57421": "AB891X", + "57422": "AB891X", + "57424": "AB891X", + "57426": "AB891X", + "57427": "AB891X", + "57428": "AB891X", + "57429": "AB891X", + "57430": "AB891X", + "57432": "AB891X", + "57433": "AB891X", + "57434": "AB891X", + "57435": "AB891X", + "57436": "AB891X", + "57437": "AB891X", + "57438": "AB891X", + "57439": "AB891X", + "57440": "AB891X", + "57441": "AB891X", + "57442": "AB891X", + "57445": "AB891X", + "57446": "AB891X", + "57448": "AB891X", + "57449": "AB891X", + "57450": "AB891X", + "57451": "AB891X", + "57452": "AB891X", + "57454": "AB891X", + "57455": "AB891X", + "57456": "AB891X", + "57457": "AB891X", + "57460": "AB891X", + "57461": "AB891X", + "57465": "AB891X", + "57466": "AB891X", + "57467": "AB891X", + "57468": "AB891X", + "57469": "AB891X", + "57470": "AB891X", + "57471": "AB891X", + "57472": "AB891X", + "57473": "AB891X", + "57474": "AB891X", + "57475": "AB891X", + "57476": "AB891X", + "57477": "AB891X", + "57479": "AB891X", + "57481": "AB891X", + "57501": "AB891X", + "57520": "AB891X", + "57521": "AB891X", + "57522": "AB891X", + "57523": "AB891X", + "57528": "AB891X", + "57529": "AB891X", + "57531": "AB891X", + "57532": "AB891X", + "57533": "AB891X", + "57534": "AB891X", + "57536": "AB891X", + "57537": "AB891X", + "57538": "AB891X", + "57540": "AB891X", + "57541": "AB891X", + "57543": "AB891X", + "57544": "AB891X", + "57547": "AB891X", + "57548": "AB891X", + "57551": "AB891X", + "57552": "AB891X", + "57553": "AB891X", + "57555": "AB891X", + "57559": "AB891X", + "57560": "AB891X", + "57562": "AB891X", + "57563": "AB891X", + "57564": "AB891X", + "57566": "AB891X", + "57567": "AB891X", + "57568": "AB891X", + "57569": "AB891X", + "57570": "AB891X", + "57571": "AB891X", + "57572": "AB891X", + "57574": "AB891X", + "57576": "AB891X", + "57577": "AB891X", + "57579": "AB891X", + "57580": "AB891X", + "57584": "AB891X", + "57585": "AB891X", + "57601": "AB891X", + "57620": "AB891X", + "57621": "AB891X", + "57622": "AB891X", + "57623": "AB891X", + "57625": "AB891X", + "57626": "AB891X", + "57630": "AB891X", + "57631": "AB891X", + "57632": "AB891X", + "57633": "AB891X", + "57634": "AB891X", + "57636": "AB891X", + "57638": "AB891X", + "57639": "AB891X", + "57640": "AB891X", + "57641": "AB891X", + "57642": "AB891X", + "57644": "AB891X", + "57645": "AB891X", + "57646": "AB891X", + "57648": "AB891X", + "57649": "AB891X", + "57650": "AB891X", + "57651": "AB891X", + "57652": "AB891X", + "57656": "AB891X", + "57657": "AB891X", + "57658": "AB891X", + "57659": "AB891X", + "57660": "AB891X", + "57661": "AB891X", + "57701": "AB887X", + "57702": "AB887X", + "57703": "AB887X", + "57706": "AB891X", + "57709": "AB887X", + "57714": "AB891X", + "57716": "AB891X", + "57717": "AB887X", + "57718": "AB891X", + "57719": "AB887X", + "57720": "AB891X", + "57722": "AB891X", + "57724": "AB891X", + "57725": "AB887X", + "57730": "AB891X", + "57732": "AB891X", + "57735": "AB891X", + "57737": "AB891X", + "57738": "AB891X", + "57741": "AB891X", + "57744": "AB891X", + "57745": "AB887X", + "57747": "AB891X", + "57748": "AB891X", + "57750": "AB891X", + "57751": "AB887X", + "57752": "AB891X", + "57754": "AB891X", + "57755": "AB891X", + "57756": "AB891X", + "57758": "AB891X", + "57759": "AB891X", + "57760": "AB887X", + "57761": "AB887X", + "57762": "AB887X", + "57763": "AB891X", + "57764": "AB891X", + "57766": "AB891X", + "57767": "AB887X", + "57769": "AB891X", + "57770": "AB891X", + "57772": "AB891X", + "57773": "AB891X", + "57775": "AB887X", + "57776": "AB891X", + "57779": "AB891X", + "57780": "AB887X", + "57782": "AB891X", + "57783": "AB891X", + "57785": "AB891X", + "57787": "AB891X", + "57788": "AB887X", + "57790": "AB887X", + "57791": "AB887X", + "57792": "AB891X", + "57793": "AB891X", + "57794": "AB891X", + "57799": "AB891X", + "58001": "AB889X", + "58002": "AB889X", + "58004": "AB889X", + "58005": "AB889X", + "58006": "AB889X", + "58007": "AB889X", + "58008": "AB889X", + "58009": "AB889X", + "58011": "AB889X", + "58012": "AB889X", + "58013": "AB889X", + "58015": "AB889X", + "58016": "AB889X", + "58017": "AB889X", + "58018": "AB889X", + "58021": "AB889X", + "58027": "AB889X", + "58029": "AB889X", + "58030": "AB889X", + "58031": "AB889X", + "58032": "AB889X", + "58033": "AB889X", + "58035": "AB889X", + "58036": "AB889X", + "58038": "AB889X", + "58040": "AB889X", + "58041": "AB889X", + "58042": "AB889X", + "58043": "AB889X", + "58045": "AB889X", + "58046": "AB889X", + "58047": "AB889X", + "58048": "AB889X", + "58049": "AB889X", + "58051": "AB889X", + "58052": "AB889X", + "58053": "AB889X", + "58054": "AB889X", + "58056": "AB889X", + "58057": "AB889X", + "58058": "AB889X", + "58059": "AB889X", + "58060": "AB889X", + "58061": "AB889X", + "58062": "AB889X", + "58063": "AB889X", + "58064": "AB889X", + "58065": "AB889X", + "58067": "AB889X", + "58068": "AB889X", + "58069": "AB889X", + "58071": "AB889X", + "58072": "AB889X", + "58074": "AB889X", + "58075": "AB889X", + "58076": "AB889X", + "58077": "AB889X", + "58078": "AB889X", + "58079": "AB889X", + "58081": "AB889X", + "58102": "AB889X", + "58103": "AB889X", + "58104": "AB889X", + "58105": "AB889X", + "58106": "AB889X", + "58107": "AB889X", + "58108": "AB889X", + "58109": "AB889X", + "58121": "AB889X", + "58122": "AB889X", + "58124": "AB889X", + "58125": "AB889X", + "58126": "AB889X", + "58201": "AB889X", + "58202": "AB889X", + "58203": "AB889X", + "58204": "AB889X", + "58205": "AB889X", + "58206": "AB889X", + "58207": "AB889X", + "58208": "AB889X", + "58210": "AB889X", + "58212": "AB889X", + "58214": "AB889X", + "58216": "AB889X", + "58218": "AB889X", + "58219": "AB889X", + "58220": "AB889X", + "58222": "AB889X", + "58223": "AB889X", + "58224": "AB889X", + "58225": "AB889X", + "58227": "AB889X", + "58228": "AB889X", + "58229": "AB889X", + "58230": "AB889X", + "58231": "AB889X", + "58233": "AB889X", + "58235": "AB889X", + "58236": "AB889X", + "58237": "AB889X", + "58238": "AB889X", + "58239": "AB889X", + "58240": "AB889X", + "58241": "AB889X", + "58243": "AB889X", + "58244": "AB889X", + "58249": "AB889X", + "58250": "AB889X", + "58251": "AB889X", + "58254": "AB889X", + "58255": "AB889X", + "58256": "AB889X", + "58257": "AB889X", + "58258": "AB889X", + "58259": "AB889X", + "58260": "AB889X", + "58261": "AB889X", + "58262": "AB889X", + "58265": "AB889X", + "58266": "AB889X", + "58267": "AB889X", + "58269": "AB889X", + "58270": "AB889X", + "58271": "AB889X", + "58272": "AB889X", + "58273": "AB889X", + "58274": "AB889X", + "58275": "AB889X", + "58276": "AB889X", + "58277": "AB889X", + "58278": "AB889X", + "58281": "AB889X", + "58282": "AB889X", + "58301": "AB889X", + "58310": "AB889X", + "58311": "AB889X", + "58313": "AB889X", + "58316": "AB889X", + "58317": "AB889X", + "58318": "AB889X", + "58319": "AB889X", + "58321": "AB889X", + "58323": "AB889X", + "58324": "AB889X", + "58325": "AB889X", + "58327": "AB889X", + "58329": "AB889X", + "58330": "AB889X", + "58331": "AB889X", + "58332": "AB889X", + "58335": "AB889X", + "58338": "AB889X", + "58339": "AB889X", + "58341": "AB889X", + "58343": "AB889X", + "58344": "AB889X", + "58345": "AB889X", + "58346": "AB889X", + "58348": "AB889X", + "58351": "AB889X", + "58352": "AB889X", + "58353": "AB889X", + "58355": "AB889X", + "58356": "AB889X", + "58357": "AB889X", + "58361": "AB889X", + "58362": "AB889X", + "58363": "AB889X", + "58365": "AB889X", + "58366": "AB889X", + "58367": "AB889X", + "58368": "AB889X", + "58369": "AB889X", + "58370": "AB889X", + "58372": "AB889X", + "58374": "AB889X", + "58377": "AB889X", + "58379": "AB889X", + "58380": "AB889X", + "58381": "AB889X", + "58382": "AB889X", + "58384": "AB889X", + "58385": "AB889X", + "58386": "AB889X", + "58401": "AB889X", + "58402": "AB889X", + "58405": "AB889X", + "58413": "AB889X", + "58415": "AB889X", + "58416": "AB889X", + "58418": "AB889X", + "58420": "AB889X", + "58421": "AB889X", + "58422": "AB889X", + "58423": "AB889X", + "58424": "AB889X", + "58425": "AB889X", + "58426": "AB889X", + "58428": "AB889X", + "58429": "AB889X", + "58430": "AB889X", + "58431": "AB889X", + "58433": "AB889X", + "58436": "AB889X", + "58438": "AB889X", + "58439": "AB889X", + "58440": "AB889X", + "58441": "AB889X", + "58442": "AB889X", + "58443": "AB889X", + "58444": "AB889X", + "58445": "AB889X", + "58448": "AB889X", + "58451": "AB889X", + "58452": "AB889X", + "58454": "AB889X", + "58455": "AB889X", + "58456": "AB889X", + "58458": "AB889X", + "58460": "AB889X", + "58461": "AB889X", + "58463": "AB889X", + "58464": "AB889X", + "58466": "AB889X", + "58467": "AB889X", + "58472": "AB889X", + "58474": "AB889X", + "58475": "AB889X", + "58476": "AB889X", + "58477": "AB889X", + "58478": "AB889X", + "58479": "AB889X", + "58480": "AB889X", + "58481": "AB889X", + "58482": "AB889X", + "58483": "AB889X", + "58484": "AB889X", + "58486": "AB889X", + "58487": "AB889X", + "58488": "AB889X", + "58490": "AB889X", + "58492": "AB889X", + "58494": "AB889X", + "58495": "AB889X", + "58496": "AB889X", + "58497": "AB889X", + "58501": "AB889X", + "58502": "AB889X", + "58503": "AB889X", + "58504": "AB889X", + "58505": "AB889X", + "58506": "AB889X", + "58507": "AB889X", + "58520": "AB889X", + "58521": "AB889X", + "58523": "AB889X", + "58524": "AB889X", + "58528": "AB889X", + "58529": "AB889X", + "58530": "AB889X", + "58531": "AB889X", + "58532": "AB889X", + "58533": "AB889X", + "58535": "AB889X", + "58538": "AB889X", + "58540": "AB889X", + "58541": "AB889X", + "58542": "AB889X", + "58544": "AB889X", + "58545": "AB889X", + "58549": "AB889X", + "58552": "AB889X", + "58554": "AB889X", + "58558": "AB889X", + "58559": "AB889X", + "58560": "AB889X", + "58561": "AB889X", + "58562": "AB889X", + "58563": "AB889X", + "58564": "AB889X", + "58565": "AB889X", + "58566": "AB889X", + "58568": "AB889X", + "58569": "AB889X", + "58570": "AB889X", + "58571": "AB889X", + "58572": "AB889X", + "58573": "AB889X", + "58575": "AB889X", + "58576": "AB889X", + "58577": "AB889X", + "58579": "AB889X", + "58580": "AB889X", + "58581": "AB889X", + "58601": "AB889X", + "58602": "AB889X", + "58620": "AB889X", + "58621": "AB889X", + "58622": "AB889X", + "58623": "AB889X", + "58625": "AB889X", + "58626": "AB889X", + "58627": "AB889X", + "58630": "AB889X", + "58631": "AB889X", + "58632": "AB889X", + "58634": "AB889X", + "58636": "AB889X", + "58638": "AB889X", + "58639": "AB889X", + "58640": "AB889X", + "58641": "AB889X", + "58642": "AB889X", + "58643": "AB889X", + "58644": "AB889X", + "58645": "AB889X", + "58646": "AB889X", + "58647": "AB889X", + "58649": "AB889X", + "58650": "AB889X", + "58651": "AB889X", + "58652": "AB889X", + "58653": "AB889X", + "58654": "AB889X", + "58655": "AB889X", + "58656": "AB889X", + "58701": "AB889X", + "58702": "AB889X", + "58703": "AB889X", + "58704": "AB889X", + "58705": "AB889X", + "58707": "AB889X", + "58710": "AB889X", + "58711": "AB889X", + "58712": "AB889X", + "58713": "AB889X", + "58716": "AB889X", + "58718": "AB889X", + "58721": "AB889X", + "58722": "AB889X", + "58723": "AB889X", + "58725": "AB889X", + "58727": "AB889X", + "58730": "AB889X", + "58731": "AB889X", + "58733": "AB889X", + "58734": "AB889X", + "58735": "AB889X", + "58736": "AB889X", + "58737": "AB889X", + "58740": "AB889X", + "58741": "AB889X", + "58744": "AB889X", + "58746": "AB889X", + "58748": "AB889X", + "58750": "AB889X", + "58752": "AB889X", + "58755": "AB889X", + "58756": "AB889X", + "58757": "AB889X", + "58758": "AB889X", + "58759": "AB889X", + "58760": "AB889X", + "58761": "AB889X", + "58762": "AB889X", + "58763": "AB889X", + "58765": "AB889X", + "58768": "AB889X", + "58769": "AB889X", + "58770": "AB889X", + "58771": "AB889X", + "58772": "AB889X", + "58773": "AB889X", + "58775": "AB889X", + "58776": "AB889X", + "58778": "AB889X", + "58779": "AB889X", + "58781": "AB889X", + "58782": "AB889X", + "58783": "AB889X", + "58784": "AB889X", + "58785": "AB889X", + "58787": "AB889X", + "58788": "AB889X", + "58789": "AB889X", + "58790": "AB889X", + "58792": "AB889X", + "58793": "AB889X", + "58794": "AB889X", + "58795": "AB889X", + "58801": "AB889X", + "58802": "AB889X", + "58830": "AB889X", + "58831": "AB889X", + "58833": "AB889X", + "58835": "AB889X", + "58838": "AB889X", + "58843": "AB889X", + "58844": "AB889X", + "58845": "AB889X", + "58847": "AB889X", + "58849": "AB889X", + "58852": "AB889X", + "58853": "AB889X", + "58854": "AB889X", + "58856": "AB889X", + "59001": "AB887X", + "59002": "AB887X", + "59003": "AB887X", + "59004": "AB887X", + "59006": "AB887X", + "59007": "AB887X", + "59008": "AB887X", + "59010": "AB887X", + "59011": "AB887X", + "59012": "AB887X", + "59013": "AB887X", + "59014": "AB887X", + "59015": "AB887X", + "59016": "AB887X", + "59018": "AB887X", + "59019": "AB887X", + "59020": "AB887X", + "59022": "AB887X", + "59024": "AB887X", + "59025": "AB887X", + "59026": "AB887X", + "59027": "AB887X", + "59028": "AB887X", + "59029": "AB887X", + "59030": "AB887X", + "59031": "AB887X", + "59032": "AB890X", + "59033": "AB887X", + "59034": "AB887X", + "59035": "AB887X", + "59036": "AB887X", + "59037": "AB887X", + "59038": "AB887X", + "59039": "AB887X", + "59041": "AB887X", + "59043": "AB887X", + "59044": "AB887X", + "59046": "AB887X", + "59047": "AB887X", + "59050": "AB887X", + "59052": "AB887X", + "59053": "AB890X", + "59054": "AB887X", + "59055": "AB887X", + "59057": "AB887X", + "59058": "AB887X", + "59059": "AB887X", + "59061": "AB887X", + "59062": "AB887X", + "59063": "AB887X", + "59064": "AB887X", + "59065": "AB887X", + "59066": "AB887X", + "59067": "AB887X", + "59068": "AB887X", + "59069": "AB887X", + "59070": "AB887X", + "59071": "AB887X", + "59072": "AB887X", + "59073": "AB887X", + "59074": "AB887X", + "59075": "AB887X", + "59076": "AB887X", + "59077": "AB887X", + "59078": "AB887X", + "59079": "AB887X", + "59081": "AB887X", + "59082": "AB887X", + "59083": "AB887X", + "59084": "AB887X", + "59085": "AB887X", + "59086": "AB887X", + "59087": "AB887X", + "59088": "AB887X", + "59089": "AB887X", + "59101": "AB887X", + "59102": "AB887X", + "59103": "AB887X", + "59104": "AB887X", + "59105": "AB887X", + "59106": "AB887X", + "59107": "AB887X", + "59108": "AB887X", + "59111": "AB887X", + "59112": "AB887X", + "59114": "AB887X", + "59115": "AB887X", + "59116": "AB887X", + "59117": "AB887X", + "59201": "AB889X", + "59211": "AB889X", + "59212": "AB889X", + "59213": "AB889X", + "59214": "AB889X", + "59215": "AB889X", + "59217": "AB889X", + "59218": "AB889X", + "59219": "AB889X", + "59221": "AB889X", + "59222": "AB890X", + "59223": "AB890X", + "59225": "AB890X", + "59226": "AB889X", + "59230": "AB890X", + "59231": "AB890X", + "59240": "AB890X", + "59241": "AB890X", + "59242": "AB889X", + "59243": "AB889X", + "59244": "AB890X", + "59247": "AB889X", + "59248": "AB890X", + "59250": "AB890X", + "59252": "AB889X", + "59253": "AB890X", + "59254": "AB889X", + "59255": "AB889X", + "59256": "AB889X", + "59257": "AB889X", + "59258": "AB889X", + "59259": "AB887X", + "59260": "AB890X", + "59261": "AB890X", + "59262": "AB889X", + "59263": "AB890X", + "59270": "AB889X", + "59273": "AB890X", + "59274": "AB889X", + "59275": "AB889X", + "59276": "AB890X", + "59301": "AB887X", + "59311": "AB887X", + "59312": "AB887X", + "59313": "AB887X", + "59314": "AB887X", + "59315": "AB887X", + "59316": "AB887X", + "59317": "AB887X", + "59318": "AB887X", + "59319": "AB887X", + "59322": "AB887X", + "59323": "AB887X", + "59324": "AB887X", + "59326": "AB887X", + "59327": "AB887X", + "59330": "AB887X", + "59332": "AB887X", + "59333": "AB887X", + "59336": "AB887X", + "59337": "AB887X", + "59338": "AB887X", + "59339": "AB887X", + "59341": "AB887X", + "59343": "AB887X", + "59344": "AB887X", + "59345": "AB887X", + "59347": "AB887X", + "59349": "AB887X", + "59351": "AB887X", + "59353": "AB887X", + "59354": "AB887X", + "59401": "AB890X", + "59402": "AB890X", + "59403": "AB890X", + "59404": "AB890X", + "59405": "AB890X", + "59406": "AB890X", + "59410": "AB887X", + "59411": "AB890X", + "59412": "AB890X", + "59414": "AB890X", + "59416": "AB890X", + "59417": "AB890X", + "59418": "AB890X", + "59419": "AB890X", + "59420": "AB890X", + "59421": "AB890X", + "59422": "AB890X", + "59424": "AB890X", + "59425": "AB890X", + "59427": "AB890X", + "59430": "AB890X", + "59432": "AB890X", + "59433": "AB890X", + "59434": "AB890X", + "59435": "AB890X", + "59436": "AB890X", + "59440": "AB890X", + "59441": "AB890X", + "59442": "AB890X", + "59443": "AB890X", + "59444": "AB890X", + "59446": "AB890X", + "59447": "AB890X", + "59448": "AB890X", + "59450": "AB890X", + "59451": "AB890X", + "59452": "AB890X", + "59453": "AB887X", + "59454": "AB890X", + "59456": "AB890X", + "59457": "AB890X", + "59460": "AB890X", + "59461": "AB890X", + "59462": "AB890X", + "59463": "AB890X", + "59464": "AB890X", + "59465": "AB890X", + "59466": "AB890X", + "59467": "AB890X", + "59468": "AB890X", + "59469": "AB890X", + "59471": "AB890X", + "59472": "AB890X", + "59474": "AB890X", + "59477": "AB890X", + "59479": "AB890X", + "59480": "AB890X", + "59482": "AB890X", + "59483": "AB890X", + "59484": "AB890X", + "59485": "AB890X", + "59486": "AB890X", + "59487": "AB890X", + "59489": "AB890X", + "59501": "AB890X", + "59520": "AB890X", + "59521": "AB890X", + "59522": "AB890X", + "59523": "AB890X", + "59524": "AB890X", + "59525": "AB890X", + "59526": "AB890X", + "59527": "AB890X", + "59528": "AB890X", + "59529": "AB890X", + "59530": "AB890X", + "59531": "AB890X", + "59532": "AB890X", + "59535": "AB890X", + "59537": "AB890X", + "59538": "AB890X", + "59540": "AB890X", + "59542": "AB890X", + "59544": "AB890X", + "59545": "AB890X", + "59546": "AB890X", + "59547": "AB890X", + "59601": "AB887X", + "59602": "AB887X", + "59604": "AB887X", + "59620": "AB887X", + "59623": "AB887X", + "59624": "AB887X", + "59625": "AB887X", + "59626": "AB887X", + "59631": "AB887X", + "59632": "AB887X", + "59633": "AB887X", + "59634": "AB887X", + "59635": "AB887X", + "59636": "AB887X", + "59638": "AB887X", + "59639": "AB887X", + "59640": "AB887X", + "59641": "AB887X", + "59642": "AB890X", + "59643": "AB887X", + "59644": "AB887X", + "59645": "AB890X", + "59647": "AB887X", + "59648": "AB887X", + "59701": "AB887X", + "59702": "AB887X", + "59703": "AB887X", + "59707": "AB887X", + "59710": "AB887X", + "59711": "AB887X", + "59713": "AB890X", + "59714": "AB887X", + "59715": "AB887X", + "59716": "AB887X", + "59717": "AB887X", + "59718": "AB887X", + "59719": "AB887X", + "59720": "AB887X", + "59721": "AB887X", + "59722": "AB890X", + "59724": "AB890X", + "59725": "AB890X", + "59727": "AB887X", + "59728": "AB890X", + "59729": "AB887X", + "59730": "AB887X", + "59731": "AB890X", + "59732": "AB890X", + "59733": "AB890X", + "59735": "AB887X", + "59736": "AB890X", + "59739": "AB890X", + "59740": "AB887X", + "59741": "AB887X", + "59743": "AB887X", + "59745": "AB887X", + "59746": "AB890X", + "59747": "AB887X", + "59748": "AB887X", + "59749": "AB887X", + "59750": "AB887X", + "59751": "AB887X", + "59752": "AB887X", + "59754": "AB887X", + "59755": "AB887X", + "59756": "AB887X", + "59758": "AB887X", + "59759": "AB887X", + "59760": "AB887X", + "59761": "AB890X", + "59762": "AB890X", + "59771": "AB887X", + "59772": "AB887X", + "59773": "AB887X", + "59801": "AB890X", + "59802": "AB890X", + "59803": "AB890X", + "59804": "AB890X", + "59806": "AB890X", + "59807": "AB890X", + "59808": "AB890X", + "59812": "AB890X", + "59820": "AB890X", + "59821": "AB890X", + "59823": "AB890X", + "59824": "AB890X", + "59825": "AB890X", + "59826": "AB890X", + "59827": "AB890X", + "59828": "AB890X", + "59829": "AB890X", + "59830": "AB890X", + "59831": "AB890X", + "59832": "AB890X", + "59833": "AB890X", + "59834": "AB890X", + "59835": "AB890X", + "59837": "AB890X", + "59840": "AB890X", + "59841": "AB890X", + "59842": "AB890X", + "59843": "AB890X", + "59844": "AB890X", + "59845": "AB890X", + "59846": "AB890X", + "59847": "AB890X", + "59848": "AB890X", + "59851": "AB890X", + "59853": "AB890X", + "59854": "AB890X", + "59855": "AB890X", + "59856": "AB890X", + "59858": "AB890X", + "59859": "AB890X", + "59860": "AB890X", + "59863": "AB890X", + "59864": "AB890X", + "59865": "AB890X", + "59866": "AB890X", + "59867": "AB890X", + "59868": "AB890X", + "59870": "AB890X", + "59871": "AB890X", + "59872": "AB890X", + "59873": "AB890X", + "59874": "AB890X", + "59875": "AB890X", + "59901": "AB890X", + "59903": "AB890X", + "59904": "AB890X", + "59910": "AB890X", + "59911": "AB890X", + "59912": "AB890X", + "59913": "AB890X", + "59914": "AB890X", + "59915": "AB890X", + "59916": "AB890X", + "59917": "AB890X", + "59918": "AB890X", + "59919": "AB890X", + "59920": "AB890X", + "59921": "AB890X", + "59922": "AB890X", + "59923": "AB890X", + "59925": "AB890X", + "59926": "AB890X", + "59927": "AB890X", + "59928": "AB890X", + "59929": "AB890X", + "59930": "AB890X", + "59931": "AB890X", + "59932": "AB890X", + "59933": "AB890X", + "59934": "AB890X", + "59935": "AB890X", + "59936": "AB890X", + "59937": "AB890X", + "60001": "AB887X", + "60002": "AB887X", + "60004": "AB887X", + "60005": "AB887X", + "60006": "AB887X", + "60007": "AB887X", + "60008": "AB887X", + "60009": "AB887X", + "60010": "AB887X", + "60011": "AB887X", + "60012": "AB887X", + "60013": "AB887X", + "60014": "AB887X", + "60015": "AB887X", + "60016": "AB887X", + "60017": "AB887X", + "60018": "AB887X", + "60019": "AB887X", + "60020": "AB887X", + "60021": "AB887X", + "60022": "AB887X", + "60025": "AB887X", + "60026": "AB887X", + "60029": "AB887X", + "60030": "AB887X", + "60031": "AB887X", + "60033": "AB887X", + "60034": "AB887X", + "60035": "AB887X", + "60037": "AB887X", + "60038": "AB887X", + "60039": "AB887X", + "60040": "AB887X", + "60041": "AB887X", + "60042": "AB887X", + "60043": "AB887X", + "60044": "AB887X", + "60045": "AB887X", + "60046": "AB887X", + "60047": "AB887X", + "60048": "AB887X", + "60049": "AB887X", + "60050": "AB887X", + "60051": "AB887X", + "60053": "AB887X", + "60055": "AB887X", + "60056": "AB887X", + "60060": "AB887X", + "60061": "AB887X", + "60062": "AB887X", + "60064": "AB887X", + "60065": "AB887X", + "60067": "AB887X", + "60068": "AB887X", + "60069": "AB887X", + "60070": "AB887X", + "60071": "AB887X", + "60072": "AB887X", + "60073": "AB887X", + "60074": "AB887X", + "60075": "AB887X", + "60076": "AB887X", + "60077": "AB887X", + "60078": "AB887X", + "60079": "AB887X", + "60081": "AB887X", + "60082": "AB887X", + "60083": "AB887X", + "60084": "AB887X", + "60085": "AB887X", + "60086": "AB887X", + "60087": "AB887X", + "60088": "AB887X", + "60089": "AB887X", + "60090": "AB887X", + "60091": "AB887X", + "60092": "AB887X", + "60093": "AB887X", + "60094": "AB887X", + "60095": "AB887X", + "60096": "AB887X", + "60097": "AB887X", + "60098": "AB887X", + "60099": "AB887X", + "60101": "AB887X", + "60102": "AB887X", + "60103": "AB887X", + "60104": "AB887X", + "60105": "AB887X", + "60106": "AB887X", + "60107": "AB887X", + "60108": "AB887X", + "60109": "AB887X", + "60110": "AB887X", + "60111": "AB887X", + "60112": "AB887X", + "60113": "AB887X", + "60115": "AB887X", + "60116": "AB887X", + "60117": "AB887X", + "60118": "AB887X", + "60119": "AB887X", + "60120": "AB887X", + "60121": "AB887X", + "60122": "AB887X", + "60123": "AB887X", + "60124": "AB887X", + "60125": "AB887X", + "60126": "AB887X", + "60128": "AB887X", + "60129": "AB887X", + "60130": "AB887X", + "60131": "AB887X", + "60132": "AB887X", + "60133": "AB887X", + "60134": "AB887X", + "60135": "AB887X", + "60136": "AB887X", + "60137": "AB887X", + "60138": "AB887X", + "60139": "AB887X", + "60140": "AB887X", + "60141": "AB887X", + "60142": "AB887X", + "60143": "AB887X", + "60144": "AB887X", + "60145": "AB887X", + "60146": "AB887X", + "60147": "AB887X", + "60148": "AB887X", + "60150": "AB887X", + "60151": "AB887X", + "60152": "AB887X", + "60153": "AB887X", + "60154": "AB887X", + "60155": "AB887X", + "60156": "AB887X", + "60157": "AB887X", + "60159": "AB887X", + "60160": "AB887X", + "60161": "AB887X", + "60162": "AB887X", + "60163": "AB887X", + "60164": "AB887X", + "60165": "AB887X", + "60168": "AB887X", + "60169": "AB887X", + "60170": "AB887X", + "60171": "AB887X", + "60172": "AB887X", + "60173": "AB887X", + "60174": "AB887X", + "60175": "AB887X", + "60176": "AB887X", + "60177": "AB887X", + "60178": "AB887X", + "60179": "AB887X", + "60180": "AB887X", + "60181": "AB887X", + "60183": "AB887X", + "60184": "AB887X", + "60185": "AB887X", + "60186": "AB887X", + "60187": "AB887X", + "60188": "AB887X", + "60189": "AB887X", + "60190": "AB887X", + "60191": "AB887X", + "60192": "AB887X", + "60193": "AB887X", + "60194": "AB887X", + "60195": "AB887X", + "60196": "AB887X", + "60197": "AB887X", + "60199": "AB887X", + "60201": "AB887X", + "60202": "AB887X", + "60203": "AB887X", + "60204": "AB887X", + "60208": "AB887X", + "60209": "AB887X", + "60296": "AB887X", + "60297": "AB887X", + "60301": "AB887X", + "60302": "AB887X", + "60303": "AB887X", + "60304": "AB887X", + "60305": "AB887X", + "60399": "AB887X", + "60401": "AB887X", + "60402": "AB887X", + "60403": "AB887X", + "60404": "AB887X", + "60406": "AB887X", + "60407": "AB887X", + "60408": "AB887X", + "60409": "AB887X", + "60410": "AB887X", + "60411": "AB887X", + "60412": "AB887X", + "60415": "AB887X", + "60416": "AB887X", + "60417": "AB887X", + "60419": "AB887X", + "60420": "AB888X", + "60421": "AB887X", + "60422": "AB887X", + "60423": "AB887X", + "60424": "AB887X", + "60425": "AB887X", + "60426": "AB887X", + "60428": "AB887X", + "60429": "AB887X", + "60430": "AB887X", + "60431": "AB887X", + "60432": "AB887X", + "60433": "AB887X", + "60434": "AB887X", + "60435": "AB887X", + "60436": "AB887X", + "60437": "AB887X", + "60438": "AB887X", + "60439": "AB887X", + "60440": "AB887X", + "60441": "AB887X", + "60442": "AB887X", + "60443": "AB887X", + "60444": "AB887X", + "60445": "AB887X", + "60446": "AB887X", + "60447": "AB887X", + "60448": "AB887X", + "60449": "AB887X", + "60450": "AB887X", + "60451": "AB887X", + "60452": "AB887X", + "60453": "AB887X", + "60454": "AB887X", + "60455": "AB887X", + "60456": "AB887X", + "60457": "AB887X", + "60458": "AB887X", + "60459": "AB887X", + "60460": "AB888X", + "60461": "AB887X", + "60462": "AB887X", + "60463": "AB887X", + "60464": "AB887X", + "60465": "AB887X", + "60466": "AB887X", + "60467": "AB887X", + "60468": "AB887X", + "60469": "AB887X", + "60470": "AB887X", + "60471": "AB887X", + "60472": "AB887X", + "60473": "AB887X", + "60474": "AB887X", + "60475": "AB887X", + "60476": "AB887X", + "60477": "AB887X", + "60478": "AB887X", + "60479": "AB887X", + "60480": "AB887X", + "60481": "AB887X", + "60482": "AB887X", + "60483": "AB887X", + "60487": "AB887X", + "60490": "AB887X", + "60491": "AB887X", + "60499": "AB887X", + "60501": "AB887X", + "60502": "AB887X", + "60503": "AB887X", + "60504": "AB887X", + "60505": "AB887X", + "60506": "AB887X", + "60507": "AB887X", + "60510": "AB887X", + "60511": "AB887X", + "60512": "AB887X", + "60513": "AB887X", + "60514": "AB887X", + "60515": "AB887X", + "60516": "AB887X", + "60517": "AB887X", + "60518": "AB887X", + "60519": "AB887X", + "60520": "AB887X", + "60521": "AB887X", + "60522": "AB887X", + "60523": "AB887X", + "60525": "AB887X", + "60526": "AB887X", + "60527": "AB887X", + "60530": "AB888X", + "60531": "AB887X", + "60532": "AB887X", + "60534": "AB887X", + "60536": "AB887X", + "60537": "AB887X", + "60538": "AB887X", + "60539": "AB887X", + "60540": "AB887X", + "60541": "AB887X", + "60542": "AB887X", + "60543": "AB887X", + "60544": "AB887X", + "60545": "AB887X", + "60546": "AB887X", + "60548": "AB887X", + "60549": "AB887X", + "60550": "AB887X", + "60551": "AB887X", + "60552": "AB887X", + "60553": "AB887X", + "60554": "AB887X", + "60555": "AB887X", + "60556": "AB887X", + "60557": "AB887X", + "60558": "AB887X", + "60559": "AB887X", + "60560": "AB887X", + "60561": "AB887X", + "60563": "AB887X", + "60564": "AB887X", + "60565": "AB887X", + "60566": "AB887X", + "60567": "AB887X", + "60568": "AB887X", + "60570": "AB887X", + "60572": "AB887X", + "60585": "AB887X", + "60586": "AB887X", + "60597": "AB887X", + "60598": "AB887X", + "60599": "AB887X", + "60601": "AB887X", + "60602": "AB887X", + "60603": "AB887X", + "60604": "AB887X", + "60605": "AB887X", + "60606": "AB887X", + "60607": "AB887X", + "60608": "AB887X", + "60609": "AB887X", + "60610": "AB887X", + "60611": "AB887X", + "60612": "AB887X", + "60613": "AB887X", + "60614": "AB887X", + "60615": "AB887X", + "60616": "AB887X", + "60617": "AB887X", + "60618": "AB887X", + "60619": "AB887X", + "60620": "AB887X", + "60621": "AB887X", + "60622": "AB887X", + "60623": "AB887X", + "60624": "AB887X", + "60625": "AB887X", + "60626": "AB887X", + "60628": "AB887X", + "60629": "AB887X", + "60630": "AB887X", + "60631": "AB887X", + "60632": "AB887X", + "60633": "AB887X", + "60634": "AB887X", + "60636": "AB887X", + "60637": "AB887X", + "60638": "AB887X", + "60639": "AB887X", + "60640": "AB887X", + "60641": "AB887X", + "60643": "AB887X", + "60644": "AB887X", + "60645": "AB887X", + "60646": "AB887X", + "60647": "AB887X", + "60649": "AB887X", + "60651": "AB887X", + "60652": "AB887X", + "60653": "AB887X", + "60654": "AB887X", + "60655": "AB887X", + "60656": "AB887X", + "60657": "AB887X", + "60659": "AB887X", + "60660": "AB887X", + "60661": "AB887X", + "60663": "AB887X", + "60664": "AB887X", + "60666": "AB887X", + "60668": "AB887X", + "60669": "AB887X", + "60670": "AB887X", + "60673": "AB887X", + "60674": "AB887X", + "60675": "AB887X", + "60677": "AB887X", + "60678": "AB887X", + "60679": "AB887X", + "60680": "AB887X", + "60681": "AB887X", + "60682": "AB887X", + "60684": "AB887X", + "60685": "AB887X", + "60686": "AB887X", + "60687": "AB887X", + "60688": "AB887X", + "60689": "AB887X", + "60690": "AB887X", + "60691": "AB887X", + "60693": "AB887X", + "60694": "AB887X", + "60695": "AB887X", + "60696": "AB887X", + "60697": "AB887X", + "60699": "AB887X", + "60701": "AB887X", + "60706": "AB887X", + "60707": "AB887X", + "60712": "AB887X", + "60714": "AB887X", + "60803": "AB887X", + "60804": "AB887X", + "60805": "AB887X", + "60827": "AB887X", + "60901": "AB887X", + "60910": "AB887X", + "60911": "AB888X", + "60912": "AB888X", + "60913": "AB887X", + "60914": "AB887X", + "60915": "AB887X", + "60917": "AB887X", + "60918": "AB888X", + "60919": "AB888X", + "60920": "AB888X", + "60921": "AB888X", + "60922": "AB888X", + "60924": "AB888X", + "60926": "AB888X", + "60927": "AB888X", + "60928": "AB888X", + "60929": "AB888X", + "60930": "AB888X", + "60931": "AB888X", + "60932": "AB888X", + "60933": "AB888X", + "60934": "AB888X", + "60935": "AB887X", + "60936": "AB888X", + "60938": "AB888X", + "60939": "AB888X", + "60940": "AB887X", + "60941": "AB887X", + "60942": "AB888X", + "60944": "AB887X", + "60945": "AB888X", + "60946": "AB888X", + "60948": "AB888X", + "60949": "AB888X", + "60950": "AB887X", + "60951": "AB888X", + "60952": "AB888X", + "60953": "AB888X", + "60954": "AB887X", + "60955": "AB888X", + "60956": "AB888X", + "60957": "AB888X", + "60959": "AB888X", + "60960": "AB888X", + "60961": "AB887X", + "60962": "AB888X", + "60963": "AB888X", + "60964": "AB887X", + "60966": "AB888X", + "60967": "AB888X", + "60968": "AB888X", + "60969": "AB887X", + "60970": "AB888X", + "60973": "AB888X", + "60974": "AB888X", + "61001": "AB888X", + "61006": "AB888X", + "61007": "AB888X", + "61008": "AB887X", + "61010": "AB888X", + "61011": "AB887X", + "61012": "AB887X", + "61013": "AB887X", + "61014": "AB888X", + "61015": "AB888X", + "61016": "AB887X", + "61018": "AB887X", + "61019": "AB887X", + "61020": "AB888X", + "61021": "AB888X", + "61024": "AB887X", + "61025": "AB888X", + "61027": "AB887X", + "61028": "AB888X", + "61029": "AB887X", + "61030": "AB888X", + "61031": "AB888X", + "61032": "AB887X", + "61036": "AB888X", + "61037": "AB888X", + "61038": "AB889X", + "61039": "AB887X", + "61041": "AB888X", + "61042": "AB888X", + "61043": "AB887X", + "61044": "AB888X", + "61046": "AB888X", + "61047": "AB888X", + "61048": "AB888X", + "61049": "AB887X", + "61050": "AB887X", + "61051": "AB888X", + "61052": "AB887X", + "61053": "AB888X", + "61054": "AB888X", + "61057": "AB888X", + "61058": "AB888X", + "61059": "AB888X", + "61060": "AB887X", + "61061": "AB888X", + "61062": "AB888X", + "61063": "AB887X", + "61064": "AB888X", + "61065": "AB887X", + "61067": "AB887X", + "61068": "AB887X", + "61070": "AB887X", + "61071": "AB888X", + "61072": "AB887X", + "61073": "AB887X", + "61074": "AB888X", + "61075": "AB888X", + "61077": "AB887X", + "61078": "AB888X", + "61079": "AB887X", + "61080": "AB887X", + "61081": "AB888X", + "61084": "AB888X", + "61085": "AB888X", + "61087": "AB888X", + "61088": "AB887X", + "61089": "AB888X", + "61091": "AB888X", + "61101": "AB887X", + "61102": "AB887X", + "61103": "AB887X", + "61104": "AB887X", + "61105": "AB887X", + "61106": "AB887X", + "61107": "AB887X", + "61108": "AB887X", + "61109": "AB887X", + "61110": "AB887X", + "61111": "AB887X", + "61112": "AB887X", + "61114": "AB887X", + "61115": "AB887X", + "61125": "AB887X", + "61126": "AB887X", + "61130": "AB887X", + "61131": "AB887X", + "61132": "AB887X", + "61201": "AB888X", + "61204": "AB888X", + "61230": "AB888X", + "61231": "AB888X", + "61232": "AB888X", + "61233": "AB888X", + "61234": "AB888X", + "61235": "AB888X", + "61236": "AB888X", + "61237": "AB888X", + "61238": "AB888X", + "61239": "AB888X", + "61240": "AB888X", + "61241": "AB888X", + "61242": "AB888X", + "61243": "AB888X", + "61244": "AB888X", + "61250": "AB888X", + "61251": "AB888X", + "61252": "AB888X", + "61254": "AB888X", + "61256": "AB888X", + "61257": "AB888X", + "61258": "AB888X", + "61259": "AB888X", + "61260": "AB888X", + "61261": "AB888X", + "61262": "AB888X", + "61263": "AB888X", + "61264": "AB888X", + "61265": "AB888X", + "61266": "AB888X", + "61270": "AB888X", + "61272": "AB888X", + "61273": "AB888X", + "61274": "AB888X", + "61275": "AB888X", + "61276": "AB888X", + "61277": "AB888X", + "61278": "AB888X", + "61279": "AB888X", + "61281": "AB888X", + "61282": "AB888X", + "61283": "AB888X", + "61284": "AB888X", + "61285": "AB888X", + "61299": "AB888X", + "61301": "AB887X", + "61310": "AB888X", + "61311": "AB888X", + "61312": "AB888X", + "61313": "AB888X", + "61314": "AB888X", + "61315": "AB888X", + "61316": "AB887X", + "61317": "AB888X", + "61318": "AB888X", + "61319": "AB888X", + "61320": "AB888X", + "61321": "AB887X", + "61322": "AB888X", + "61323": "AB888X", + "61324": "AB888X", + "61325": "AB887X", + "61326": "AB888X", + "61327": "AB888X", + "61328": "AB888X", + "61329": "AB888X", + "61330": "AB888X", + "61331": "AB888X", + "61332": "AB887X", + "61333": "AB888X", + "61334": "AB887X", + "61335": "AB888X", + "61336": "AB888X", + "61337": "AB888X", + "61338": "AB888X", + "61340": "AB888X", + "61341": "AB887X", + "61342": "AB887X", + "61344": "AB888X", + "61345": "AB888X", + "61346": "AB888X", + "61348": "AB887X", + "61349": "AB888X", + "61350": "AB887X", + "61353": "AB888X", + "61354": "AB887X", + "61355": "AB888X", + "61356": "AB888X", + "61358": "AB887X", + "61359": "AB888X", + "61360": "AB887X", + "61361": "AB888X", + "61362": "AB888X", + "61363": "AB888X", + "61364": "AB887X", + "61367": "AB888X", + "61368": "AB888X", + "61369": "AB888X", + "61370": "AB887X", + "61371": "AB887X", + "61372": "AB887X", + "61373": "AB887X", + "61374": "AB888X", + "61375": "AB888X", + "61376": "AB888X", + "61377": "AB888X", + "61378": "AB888X", + "61379": "AB888X", + "61401": "AB888X", + "61402": "AB888X", + "61410": "AB888X", + "61411": "AB888X", + "61412": "AB888X", + "61413": "AB888X", + "61414": "AB888X", + "61415": "AB888X", + "61416": "AB888X", + "61417": "AB888X", + "61418": "AB888X", + "61419": "AB888X", + "61420": "AB888X", + "61421": "AB888X", + "61422": "AB888X", + "61423": "AB888X", + "61424": "AB888X", + "61425": "AB888X", + "61426": "AB888X", + "61427": "AB888X", + "61428": "AB888X", + "61430": "AB888X", + "61431": "AB888X", + "61432": "AB888X", + "61433": "AB888X", + "61434": "AB888X", + "61435": "AB888X", + "61436": "AB888X", + "61437": "AB888X", + "61438": "AB888X", + "61439": "AB888X", + "61440": "AB888X", + "61441": "AB888X", + "61442": "AB888X", + "61443": "AB888X", + "61447": "AB888X", + "61448": "AB888X", + "61449": "AB888X", + "61450": "AB888X", + "61451": "AB888X", + "61452": "AB888X", + "61453": "AB888X", + "61454": "AB888X", + "61455": "AB888X", + "61458": "AB888X", + "61459": "AB888X", + "61460": "AB888X", + "61462": "AB888X", + "61465": "AB888X", + "61466": "AB888X", + "61467": "AB888X", + "61468": "AB888X", + "61469": "AB888X", + "61470": "AB888X", + "61471": "AB888X", + "61472": "AB888X", + "61473": "AB888X", + "61474": "AB888X", + "61475": "AB888X", + "61476": "AB888X", + "61477": "AB888X", + "61478": "AB888X", + "61479": "AB888X", + "61480": "AB888X", + "61482": "AB888X", + "61483": "AB888X", + "61484": "AB888X", + "61485": "AB888X", + "61486": "AB888X", + "61488": "AB888X", + "61489": "AB888X", + "61490": "AB888X", + "61491": "AB888X", + "61501": "AB888X", + "61516": "AB888X", + "61517": "AB888X", + "61519": "AB888X", + "61520": "AB888X", + "61523": "AB888X", + "61524": "AB888X", + "61525": "AB888X", + "61526": "AB888X", + "61528": "AB888X", + "61529": "AB888X", + "61530": "AB888X", + "61531": "AB888X", + "61532": "AB888X", + "61533": "AB888X", + "61534": "AB888X", + "61535": "AB888X", + "61536": "AB888X", + "61537": "AB888X", + "61539": "AB888X", + "61540": "AB888X", + "61541": "AB888X", + "61542": "AB888X", + "61543": "AB888X", + "61544": "AB888X", + "61545": "AB888X", + "61546": "AB888X", + "61547": "AB888X", + "61548": "AB888X", + "61550": "AB888X", + "61552": "AB888X", + "61553": "AB888X", + "61554": "AB888X", + "61555": "AB888X", + "61558": "AB888X", + "61559": "AB888X", + "61560": "AB888X", + "61561": "AB888X", + "61562": "AB888X", + "61563": "AB888X", + "61564": "AB888X", + "61565": "AB888X", + "61567": "AB888X", + "61568": "AB888X", + "61569": "AB888X", + "61570": "AB888X", + "61571": "AB888X", + "61572": "AB888X", + "61601": "AB888X", + "61602": "AB888X", + "61603": "AB888X", + "61604": "AB888X", + "61605": "AB888X", + "61606": "AB888X", + "61607": "AB888X", + "61610": "AB888X", + "61611": "AB888X", + "61612": "AB888X", + "61613": "AB888X", + "61614": "AB888X", + "61615": "AB888X", + "61616": "AB888X", + "61619": "AB888X", + "61625": "AB888X", + "61629": "AB888X", + "61630": "AB888X", + "61633": "AB888X", + "61634": "AB888X", + "61635": "AB888X", + "61636": "AB888X", + "61637": "AB888X", + "61638": "AB888X", + "61639": "AB888X", + "61641": "AB888X", + "61643": "AB888X", + "61650": "AB888X", + "61651": "AB888X", + "61652": "AB888X", + "61653": "AB888X", + "61654": "AB888X", + "61655": "AB888X", + "61656": "AB888X", + "61701": "AB888X", + "61702": "AB888X", + "61704": "AB888X", + "61705": "AB888X", + "61709": "AB888X", + "61710": "AB888X", + "61720": "AB888X", + "61721": "AB888X", + "61722": "AB888X", + "61723": "AB888X", + "61724": "AB888X", + "61725": "AB888X", + "61726": "AB888X", + "61727": "AB888X", + "61728": "AB888X", + "61729": "AB888X", + "61730": "AB888X", + "61731": "AB888X", + "61732": "AB888X", + "61733": "AB888X", + "61734": "AB888X", + "61735": "AB888X", + "61736": "AB888X", + "61737": "AB888X", + "61738": "AB888X", + "61739": "AB888X", + "61740": "AB888X", + "61741": "AB888X", + "61742": "AB888X", + "61743": "AB888X", + "61744": "AB888X", + "61745": "AB888X", + "61747": "AB888X", + "61748": "AB888X", + "61749": "AB888X", + "61750": "AB888X", + "61751": "AB888X", + "61752": "AB888X", + "61753": "AB888X", + "61754": "AB888X", + "61755": "AB888X", + "61756": "AB888X", + "61758": "AB888X", + "61759": "AB888X", + "61760": "AB888X", + "61761": "AB888X", + "61764": "AB888X", + "61769": "AB888X", + "61770": "AB888X", + "61771": "AB888X", + "61772": "AB888X", + "61773": "AB888X", + "61774": "AB888X", + "61775": "AB888X", + "61776": "AB888X", + "61777": "AB888X", + "61778": "AB888X", + "61790": "AB888X", + "61791": "AB888X", + "61799": "AB888X", + "61801": "AB888X", + "61802": "AB888X", + "61803": "AB888X", + "61810": "AB888X", + "61811": "AB888X", + "61812": "AB888X", + "61813": "AB888X", + "61814": "AB888X", + "61815": "AB888X", + "61816": "AB888X", + "61817": "AB888X", + "61818": "AB888X", + "61820": "AB888X", + "61821": "AB888X", + "61822": "AB888X", + "61824": "AB888X", + "61825": "AB888X", + "61826": "AB888X", + "61830": "AB888X", + "61831": "AB888X", + "61832": "AB888X", + "61833": "AB888X", + "61834": "AB888X", + "61839": "AB888X", + "61840": "AB888X", + "61841": "AB888X", + "61842": "AB888X", + "61843": "AB888X", + "61844": "AB888X", + "61845": "AB888X", + "61846": "AB888X", + "61847": "AB888X", + "61848": "AB888X", + "61849": "AB888X", + "61850": "AB888X", + "61851": "AB888X", + "61852": "AB888X", + "61853": "AB888X", + "61854": "AB888X", + "61855": "AB888X", + "61856": "AB888X", + "61857": "AB888X", + "61858": "AB888X", + "61859": "AB888X", + "61862": "AB888X", + "61863": "AB888X", + "61864": "AB888X", + "61865": "AB888X", + "61866": "AB888X", + "61870": "AB888X", + "61871": "AB888X", + "61872": "AB888X", + "61873": "AB888X", + "61874": "AB888X", + "61875": "AB888X", + "61876": "AB888X", + "61877": "AB888X", + "61878": "AB888X", + "61880": "AB888X", + "61882": "AB888X", + "61883": "AB888X", + "61884": "AB888X", + "61910": "AB888X", + "61911": "AB888X", + "61912": "AB888X", + "61913": "AB888X", + "61914": "AB888X", + "61917": "AB888X", + "61919": "AB888X", + "61920": "AB888X", + "61924": "AB888X", + "61925": "AB888X", + "61928": "AB888X", + "61929": "AB888X", + "61930": "AB888X", + "61931": "AB888X", + "61932": "AB888X", + "61933": "AB888X", + "61936": "AB888X", + "61937": "AB888X", + "61938": "AB888X", + "61940": "AB888X", + "61941": "AB888X", + "61942": "AB888X", + "61943": "AB888X", + "61944": "AB888X", + "61949": "AB888X", + "61951": "AB888X", + "61953": "AB888X", + "61955": "AB888X", + "61956": "AB888X", + "61957": "AB888X", + "62001": "AB888X", + "62002": "AB888X", + "62006": "AB888X", + "62009": "AB888X", + "62010": "AB888X", + "62011": "AB888X", + "62012": "AB888X", + "62013": "AB888X", + "62014": "AB888X", + "62015": "AB888X", + "62016": "AB888X", + "62017": "AB888X", + "62018": "AB888X", + "62019": "AB888X", + "62021": "AB888X", + "62022": "AB888X", + "62023": "AB888X", + "62024": "AB888X", + "62025": "AB888X", + "62026": "AB888X", + "62027": "AB888X", + "62028": "AB888X", + "62030": "AB888X", + "62031": "AB888X", + "62032": "AB888X", + "62033": "AB888X", + "62034": "AB888X", + "62035": "AB888X", + "62036": "AB888X", + "62037": "AB888X", + "62040": "AB888X", + "62044": "AB888X", + "62045": "AB888X", + "62046": "AB888X", + "62047": "AB888X", + "62048": "AB888X", + "62049": "AB888X", + "62050": "AB888X", + "62051": "AB888X", + "62052": "AB888X", + "62053": "AB888X", + "62054": "AB888X", + "62056": "AB888X", + "62058": "AB888X", + "62059": "AB888X", + "62060": "AB888X", + "62061": "AB888X", + "62062": "AB888X", + "62063": "AB888X", + "62065": "AB888X", + "62067": "AB888X", + "62069": "AB888X", + "62070": "AB888X", + "62071": "AB888X", + "62074": "AB888X", + "62075": "AB888X", + "62076": "AB888X", + "62077": "AB888X", + "62078": "AB888X", + "62079": "AB888X", + "62080": "AB888X", + "62081": "AB888X", + "62082": "AB888X", + "62083": "AB888X", + "62084": "AB888X", + "62085": "AB888X", + "62086": "AB888X", + "62087": "AB888X", + "62088": "AB888X", + "62089": "AB888X", + "62090": "AB888X", + "62091": "AB888X", + "62092": "AB888X", + "62093": "AB888X", + "62094": "AB888X", + "62095": "AB888X", + "62097": "AB888X", + "62098": "AB888X", + "62201": "AB888X", + "62202": "AB888X", + "62203": "AB888X", + "62204": "AB888X", + "62205": "AB888X", + "62206": "AB888X", + "62207": "AB888X", + "62208": "AB888X", + "62214": "AB888X", + "62215": "AB888X", + "62216": "AB888X", + "62217": "AB888X", + "62218": "AB888X", + "62219": "AB888X", + "62220": "AB888X", + "62221": "AB888X", + "62222": "AB888X", + "62223": "AB888X", + "62224": "AB888X", + "62225": "AB888X", + "62226": "AB888X", + "62230": "AB888X", + "62231": "AB888X", + "62232": "AB888X", + "62233": "AB888X", + "62234": "AB888X", + "62236": "AB888X", + "62237": "AB888X", + "62238": "AB888X", + "62239": "AB888X", + "62240": "AB888X", + "62241": "AB888X", + "62242": "AB888X", + "62243": "AB888X", + "62244": "AB888X", + "62245": "AB888X", + "62246": "AB888X", + "62247": "AB888X", + "62248": "AB888X", + "62249": "AB888X", + "62250": "AB888X", + "62252": "AB888X", + "62253": "AB888X", + "62254": "AB888X", + "62255": "AB888X", + "62256": "AB888X", + "62257": "AB888X", + "62258": "AB888X", + "62259": "AB888X", + "62260": "AB888X", + "62261": "AB888X", + "62262": "AB888X", + "62263": "AB888X", + "62264": "AB888X", + "62265": "AB888X", + "62266": "AB888X", + "62268": "AB888X", + "62269": "AB888X", + "62271": "AB888X", + "62272": "AB888X", + "62273": "AB888X", + "62274": "AB888X", + "62275": "AB888X", + "62277": "AB888X", + "62278": "AB888X", + "62279": "AB888X", + "62280": "AB888X", + "62281": "AB888X", + "62282": "AB888X", + "62284": "AB888X", + "62285": "AB888X", + "62286": "AB888X", + "62288": "AB888X", + "62289": "AB888X", + "62292": "AB888X", + "62293": "AB888X", + "62294": "AB888X", + "62295": "AB888X", + "62297": "AB888X", + "62298": "AB888X", + "62301": "AB888X", + "62305": "AB888X", + "62306": "AB888X", + "62311": "AB888X", + "62312": "AB888X", + "62313": "AB888X", + "62314": "AB888X", + "62316": "AB888X", + "62319": "AB888X", + "62320": "AB888X", + "62321": "AB888X", + "62323": "AB888X", + "62324": "AB888X", + "62325": "AB888X", + "62326": "AB888X", + "62329": "AB888X", + "62330": "AB888X", + "62334": "AB888X", + "62336": "AB888X", + "62338": "AB888X", + "62339": "AB888X", + "62340": "AB888X", + "62341": "AB888X", + "62343": "AB888X", + "62344": "AB888X", + "62345": "AB888X", + "62346": "AB888X", + "62347": "AB888X", + "62348": "AB888X", + "62349": "AB888X", + "62351": "AB888X", + "62352": "AB888X", + "62353": "AB888X", + "62354": "AB888X", + "62355": "AB888X", + "62356": "AB888X", + "62357": "AB888X", + "62358": "AB888X", + "62359": "AB888X", + "62360": "AB888X", + "62361": "AB888X", + "62362": "AB888X", + "62363": "AB888X", + "62365": "AB888X", + "62366": "AB888X", + "62367": "AB888X", + "62370": "AB888X", + "62373": "AB888X", + "62374": "AB888X", + "62375": "AB888X", + "62376": "AB888X", + "62378": "AB888X", + "62379": "AB888X", + "62380": "AB888X", + "62401": "AB888X", + "62410": "AB888X", + "62411": "AB888X", + "62413": "AB888X", + "62414": "AB888X", + "62417": "AB888X", + "62418": "AB888X", + "62419": "AB888X", + "62420": "AB888X", + "62421": "AB888X", + "62422": "AB888X", + "62423": "AB888X", + "62424": "AB888X", + "62425": "AB888X", + "62426": "AB888X", + "62427": "AB888X", + "62428": "AB888X", + "62431": "AB888X", + "62432": "AB888X", + "62433": "AB888X", + "62434": "AB888X", + "62435": "AB888X", + "62436": "AB888X", + "62438": "AB888X", + "62439": "AB888X", + "62440": "AB888X", + "62441": "AB888X", + "62442": "AB888X", + "62443": "AB888X", + "62444": "AB888X", + "62445": "AB888X", + "62446": "AB888X", + "62447": "AB888X", + "62448": "AB888X", + "62449": "AB888X", + "62450": "AB888X", + "62451": "AB888X", + "62452": "AB888X", + "62454": "AB888X", + "62458": "AB888X", + "62459": "AB888X", + "62460": "AB888X", + "62461": "AB888X", + "62462": "AB888X", + "62463": "AB888X", + "62464": "AB888X", + "62465": "AB888X", + "62466": "AB888X", + "62467": "AB888X", + "62468": "AB888X", + "62469": "AB888X", + "62471": "AB888X", + "62473": "AB888X", + "62474": "AB888X", + "62475": "AB888X", + "62476": "AB888X", + "62477": "AB888X", + "62478": "AB888X", + "62479": "AB888X", + "62480": "AB888X", + "62481": "AB888X", + "62485": "AB888X", + "62501": "AB888X", + "62510": "AB888X", + "62512": "AB888X", + "62513": "AB888X", + "62514": "AB888X", + "62515": "AB888X", + "62517": "AB888X", + "62518": "AB888X", + "62519": "AB888X", + "62520": "AB888X", + "62521": "AB888X", + "62522": "AB888X", + "62523": "AB888X", + "62524": "AB888X", + "62525": "AB888X", + "62526": "AB888X", + "62530": "AB888X", + "62531": "AB888X", + "62532": "AB888X", + "62533": "AB888X", + "62534": "AB888X", + "62535": "AB888X", + "62536": "AB888X", + "62537": "AB888X", + "62538": "AB888X", + "62539": "AB888X", + "62540": "AB888X", + "62541": "AB888X", + "62543": "AB888X", + "62544": "AB888X", + "62545": "AB888X", + "62546": "AB888X", + "62547": "AB888X", + "62548": "AB888X", + "62549": "AB888X", + "62550": "AB888X", + "62551": "AB888X", + "62553": "AB888X", + "62554": "AB888X", + "62555": "AB888X", + "62556": "AB888X", + "62557": "AB888X", + "62558": "AB888X", + "62560": "AB888X", + "62561": "AB888X", + "62563": "AB888X", + "62565": "AB888X", + "62566": "AB888X", + "62567": "AB888X", + "62568": "AB888X", + "62570": "AB888X", + "62571": "AB888X", + "62572": "AB888X", + "62573": "AB888X", + "62601": "AB888X", + "62610": "AB888X", + "62611": "AB888X", + "62612": "AB888X", + "62613": "AB888X", + "62615": "AB888X", + "62617": "AB888X", + "62618": "AB888X", + "62621": "AB888X", + "62622": "AB888X", + "62624": "AB888X", + "62625": "AB888X", + "62626": "AB888X", + "62627": "AB888X", + "62628": "AB888X", + "62629": "AB888X", + "62630": "AB888X", + "62631": "AB888X", + "62633": "AB888X", + "62634": "AB888X", + "62635": "AB888X", + "62638": "AB888X", + "62639": "AB888X", + "62640": "AB888X", + "62642": "AB888X", + "62643": "AB888X", + "62644": "AB888X", + "62649": "AB888X", + "62650": "AB888X", + "62651": "AB888X", + "62655": "AB888X", + "62656": "AB888X", + "62659": "AB888X", + "62660": "AB888X", + "62661": "AB888X", + "62662": "AB888X", + "62663": "AB888X", + "62664": "AB888X", + "62665": "AB888X", + "62666": "AB888X", + "62667": "AB888X", + "62668": "AB888X", + "62670": "AB888X", + "62671": "AB888X", + "62672": "AB888X", + "62673": "AB888X", + "62674": "AB888X", + "62675": "AB888X", + "62677": "AB888X", + "62681": "AB888X", + "62682": "AB888X", + "62683": "AB888X", + "62684": "AB888X", + "62685": "AB888X", + "62688": "AB888X", + "62689": "AB888X", + "62690": "AB888X", + "62691": "AB888X", + "62692": "AB888X", + "62693": "AB888X", + "62694": "AB888X", + "62695": "AB888X", + "62701": "AB888X", + "62702": "AB888X", + "62703": "AB888X", + "62704": "AB888X", + "62705": "AB888X", + "62706": "AB888X", + "62707": "AB888X", + "62708": "AB888X", + "62711": "AB888X", + "62712": "AB888X", + "62713": "AB888X", + "62715": "AB888X", + "62716": "AB888X", + "62719": "AB888X", + "62721": "AB888X", + "62722": "AB888X", + "62723": "AB888X", + "62726": "AB888X", + "62736": "AB888X", + "62739": "AB888X", + "62746": "AB888X", + "62756": "AB888X", + "62757": "AB888X", + "62761": "AB888X", + "62762": "AB888X", + "62763": "AB888X", + "62764": "AB888X", + "62765": "AB888X", + "62766": "AB888X", + "62767": "AB888X", + "62769": "AB888X", + "62776": "AB888X", + "62777": "AB888X", + "62781": "AB888X", + "62786": "AB888X", + "62791": "AB888X", + "62794": "AB888X", + "62796": "AB888X", + "62801": "AB888X", + "62803": "AB888X", + "62805": "AB888X", + "62806": "AB888X", + "62807": "AB888X", + "62808": "AB888X", + "62809": "AB888X", + "62810": "AB888X", + "62811": "AB888X", + "62812": "AB888X", + "62814": "AB888X", + "62815": "AB888X", + "62816": "AB888X", + "62817": "AB888X", + "62818": "AB888X", + "62819": "AB888X", + "62820": "AB888X", + "62821": "AB888X", + "62822": "AB888X", + "62823": "AB888X", + "62824": "AB888X", + "62825": "AB888X", + "62827": "AB888X", + "62828": "AB888X", + "62829": "AB888X", + "62830": "AB888X", + "62831": "AB888X", + "62832": "AB888X", + "62833": "AB888X", + "62834": "AB888X", + "62835": "AB888X", + "62836": "AB888X", + "62837": "AB888X", + "62838": "AB888X", + "62839": "AB888X", + "62840": "AB888X", + "62841": "AB888X", + "62842": "AB888X", + "62843": "AB888X", + "62844": "AB888X", + "62846": "AB888X", + "62848": "AB888X", + "62849": "AB888X", + "62850": "AB888X", + "62851": "AB888X", + "62852": "AB888X", + "62853": "AB888X", + "62854": "AB888X", + "62855": "AB888X", + "62856": "AB888X", + "62857": "AB888X", + "62858": "AB888X", + "62859": "AB888X", + "62860": "AB888X", + "62861": "AB888X", + "62862": "AB888X", + "62863": "AB888X", + "62864": "AB888X", + "62865": "AB888X", + "62866": "AB888X", + "62867": "AB888X", + "62868": "AB888X", + "62869": "AB888X", + "62870": "AB888X", + "62871": "AB888X", + "62872": "AB888X", + "62874": "AB888X", + "62875": "AB888X", + "62876": "AB888X", + "62877": "AB888X", + "62878": "AB888X", + "62879": "AB888X", + "62880": "AB888X", + "62881": "AB888X", + "62882": "AB888X", + "62883": "AB888X", + "62884": "AB888X", + "62885": "AB888X", + "62886": "AB888X", + "62887": "AB888X", + "62888": "AB888X", + "62889": "AB888X", + "62890": "AB888X", + "62891": "AB888X", + "62892": "AB888X", + "62893": "AB888X", + "62894": "AB888X", + "62895": "AB888X", + "62896": "AB888X", + "62897": "AB888X", + "62898": "AB888X", + "62899": "AB888X", + "62901": "AB888X", + "62902": "AB888X", + "62903": "AB888X", + "62905": "AB888X", + "62906": "AB888X", + "62907": "AB888X", + "62908": "AB888X", + "62909": "AB888X", + "62910": "AB888X", + "62912": "AB888X", + "62914": "AB888X", + "62915": "AB888X", + "62916": "AB888X", + "62917": "AB888X", + "62918": "AB888X", + "62919": "AB888X", + "62920": "AB888X", + "62921": "AB888X", + "62922": "AB888X", + "62923": "AB888X", + "62924": "AB888X", + "62926": "AB888X", + "62927": "AB888X", + "62928": "AB888X", + "62930": "AB888X", + "62931": "AB888X", + "62932": "AB888X", + "62933": "AB888X", + "62934": "AB888X", + "62935": "AB888X", + "62938": "AB888X", + "62939": "AB888X", + "62940": "AB888X", + "62941": "AB888X", + "62942": "AB888X", + "62943": "AB888X", + "62946": "AB888X", + "62947": "AB888X", + "62948": "AB888X", + "62949": "AB888X", + "62950": "AB888X", + "62951": "AB888X", + "62952": "AB888X", + "62953": "AB888X", + "62954": "AB888X", + "62955": "AB888X", + "62956": "AB888X", + "62957": "AB888X", + "62958": "AB888X", + "62959": "AB888X", + "62960": "AB888X", + "62961": "AB888X", + "62962": "AB888X", + "62963": "AB888X", + "62964": "AB888X", + "62965": "AB888X", + "62966": "AB888X", + "62967": "AB888X", + "62969": "AB888X", + "62970": "AB888X", + "62971": "AB888X", + "62972": "AB888X", + "62973": "AB888X", + "62974": "AB888X", + "62975": "AB888X", + "62976": "AB888X", + "62977": "AB888X", + "62979": "AB888X", + "62982": "AB888X", + "62983": "AB888X", + "62984": "AB888X", + "62985": "AB888X", + "62987": "AB888X", + "62988": "AB888X", + "62990": "AB888X", + "62992": "AB888X", + "62993": "AB888X", + "62994": "AB888X", + "62995": "AB888X", + "62996": "AB888X", + "62997": "AB888X", + "62998": "AB888X", + "62999": "AB888X", + "63001": "AB888X", + "63005": "AB888X", + "63006": "AB888X", + "63010": "AB888X", + "63011": "AB888X", + "63012": "AB888X", + "63013": "AB888X", + "63014": "AB888X", + "63015": "AB888X", + "63016": "AB888X", + "63017": "AB888X", + "63019": "AB888X", + "63020": "AB888X", + "63021": "AB888X", + "63022": "AB888X", + "63023": "AB888X", + "63024": "AB888X", + "63025": "AB888X", + "63026": "AB888X", + "63028": "AB888X", + "63030": "AB888X", + "63031": "AB888X", + "63032": "AB888X", + "63033": "AB888X", + "63034": "AB888X", + "63036": "AB888X", + "63037": "AB888X", + "63038": "AB888X", + "63039": "AB888X", + "63040": "AB888X", + "63041": "AB888X", + "63042": "AB888X", + "63043": "AB888X", + "63044": "AB888X", + "63045": "AB888X", + "63047": "AB888X", + "63048": "AB888X", + "63049": "AB888X", + "63050": "AB888X", + "63051": "AB888X", + "63052": "AB888X", + "63053": "AB888X", + "63055": "AB888X", + "63056": "AB888X", + "63057": "AB888X", + "63060": "AB888X", + "63061": "AB888X", + "63065": "AB888X", + "63066": "AB888X", + "63068": "AB888X", + "63069": "AB888X", + "63070": "AB888X", + "63071": "AB888X", + "63072": "AB888X", + "63073": "AB888X", + "63074": "AB888X", + "63077": "AB888X", + "63079": "AB888X", + "63080": "AB888X", + "63084": "AB888X", + "63087": "AB888X", + "63088": "AB888X", + "63089": "AB888X", + "63090": "AB888X", + "63091": "AB888X", + "63099": "AB888X", + "63101": "AB888X", + "63102": "AB888X", + "63103": "AB888X", + "63104": "AB888X", + "63105": "AB888X", + "63106": "AB888X", + "63107": "AB888X", + "63108": "AB888X", + "63109": "AB888X", + "63110": "AB888X", + "63111": "AB888X", + "63112": "AB888X", + "63113": "AB888X", + "63114": "AB888X", + "63115": "AB888X", + "63116": "AB888X", + "63117": "AB888X", + "63118": "AB888X", + "63119": "AB888X", + "63120": "AB888X", + "63121": "AB888X", + "63122": "AB888X", + "63123": "AB888X", + "63124": "AB888X", + "63125": "AB888X", + "63126": "AB888X", + "63127": "AB888X", + "63128": "AB888X", + "63129": "AB888X", + "63130": "AB888X", + "63131": "AB888X", + "63132": "AB888X", + "63133": "AB888X", + "63134": "AB888X", + "63135": "AB888X", + "63136": "AB888X", + "63137": "AB888X", + "63138": "AB888X", + "63139": "AB888X", + "63140": "AB888X", + "63141": "AB888X", + "63143": "AB888X", + "63144": "AB888X", + "63145": "AB888X", + "63146": "AB888X", + "63147": "AB888X", + "63150": "AB888X", + "63151": "AB888X", + "63155": "AB888X", + "63156": "AB888X", + "63157": "AB888X", + "63158": "AB888X", + "63160": "AB888X", + "63163": "AB888X", + "63164": "AB888X", + "63166": "AB888X", + "63167": "AB888X", + "63169": "AB888X", + "63171": "AB888X", + "63177": "AB888X", + "63178": "AB888X", + "63179": "AB888X", + "63180": "AB888X", + "63182": "AB888X", + "63188": "AB888X", + "63190": "AB888X", + "63195": "AB888X", + "63196": "AB888X", + "63197": "AB888X", + "63198": "AB888X", + "63199": "AB888X", + "63301": "AB888X", + "63302": "AB888X", + "63303": "AB888X", + "63304": "AB888X", + "63330": "AB888X", + "63332": "AB888X", + "63333": "AB888X", + "63334": "AB888X", + "63336": "AB888X", + "63338": "AB888X", + "63339": "AB888X", + "63341": "AB888X", + "63342": "AB888X", + "63343": "AB888X", + "63344": "AB888X", + "63345": "AB888X", + "63346": "AB888X", + "63347": "AB888X", + "63348": "AB888X", + "63349": "AB888X", + "63350": "AB888X", + "63351": "AB888X", + "63352": "AB888X", + "63353": "AB888X", + "63357": "AB888X", + "63359": "AB888X", + "63361": "AB888X", + "63362": "AB888X", + "63363": "AB888X", + "63365": "AB888X", + "63366": "AB888X", + "63367": "AB888X", + "63368": "AB888X", + "63369": "AB888X", + "63370": "AB888X", + "63373": "AB888X", + "63376": "AB888X", + "63377": "AB888X", + "63378": "AB888X", + "63379": "AB888X", + "63381": "AB888X", + "63382": "AB888X", + "63383": "AB888X", + "63384": "AB888X", + "63385": "AB888X", + "63386": "AB888X", + "63387": "AB888X", + "63388": "AB888X", + "63389": "AB888X", + "63390": "AB888X", + "63401": "AB888X", + "63430": "AB888X", + "63431": "AB888X", + "63432": "AB888X", + "63433": "AB888X", + "63434": "AB888X", + "63435": "AB888X", + "63436": "AB888X", + "63437": "AB888X", + "63438": "AB888X", + "63439": "AB888X", + "63440": "AB888X", + "63441": "AB888X", + "63442": "AB888X", + "63443": "AB888X", + "63445": "AB888X", + "63446": "AB888X", + "63447": "AB888X", + "63448": "AB888X", + "63450": "AB888X", + "63451": "AB888X", + "63452": "AB888X", + "63453": "AB888X", + "63454": "AB888X", + "63456": "AB888X", + "63457": "AB888X", + "63458": "AB888X", + "63459": "AB888X", + "63460": "AB888X", + "63461": "AB888X", + "63462": "AB888X", + "63463": "AB888X", + "63464": "AB888X", + "63465": "AB888X", + "63466": "AB888X", + "63467": "AB888X", + "63468": "AB888X", + "63469": "AB888X", + "63471": "AB888X", + "63472": "AB888X", + "63473": "AB888X", + "63474": "AB888X", + "63501": "AB888X", + "63530": "AB888X", + "63531": "AB888X", + "63532": "AB888X", + "63533": "AB888X", + "63534": "AB888X", + "63535": "AB888X", + "63536": "AB888X", + "63537": "AB888X", + "63538": "AB888X", + "63539": "AB888X", + "63540": "AB888X", + "63541": "AB888X", + "63543": "AB888X", + "63544": "AB888X", + "63545": "AB888X", + "63546": "AB888X", + "63547": "AB888X", + "63548": "AB888X", + "63549": "AB888X", + "63551": "AB888X", + "63552": "AB888X", + "63555": "AB888X", + "63556": "AB888X", + "63557": "AB888X", + "63558": "AB888X", + "63559": "AB888X", + "63560": "AB888X", + "63561": "AB888X", + "63563": "AB888X", + "63565": "AB888X", + "63566": "AB888X", + "63567": "AB888X", + "63601": "AB888X", + "63620": "AB888X", + "63621": "AB888X", + "63622": "AB888X", + "63623": "AB888X", + "63624": "AB888X", + "63625": "AB888X", + "63626": "AB888X", + "63627": "AB888X", + "63628": "AB888X", + "63629": "AB888X", + "63630": "AB888X", + "63631": "AB888X", + "63632": "AB888X", + "63633": "AB888X", + "63636": "AB888X", + "63637": "AB888X", + "63638": "AB888X", + "63640": "AB888X", + "63645": "AB888X", + "63648": "AB888X", + "63650": "AB888X", + "63651": "AB888X", + "63653": "AB888X", + "63654": "AB888X", + "63655": "AB888X", + "63656": "AB888X", + "63660": "AB888X", + "63662": "AB888X", + "63663": "AB888X", + "63664": "AB888X", + "63665": "AB888X", + "63666": "AB888X", + "63670": "AB888X", + "63673": "AB888X", + "63674": "AB888X", + "63675": "AB888X", + "63701": "AB888X", + "63702": "AB888X", + "63703": "AB888X", + "63730": "AB888X", + "63732": "AB888X", + "63735": "AB888X", + "63736": "AB888X", + "63737": "AB888X", + "63738": "AB888X", + "63739": "AB888X", + "63740": "AB888X", + "63742": "AB888X", + "63743": "AB888X", + "63744": "AB888X", + "63745": "AB888X", + "63746": "AB888X", + "63747": "AB888X", + "63748": "AB888X", + "63750": "AB888X", + "63751": "AB888X", + "63752": "AB888X", + "63755": "AB888X", + "63758": "AB888X", + "63760": "AB888X", + "63763": "AB888X", + "63764": "AB888X", + "63766": "AB888X", + "63767": "AB888X", + "63769": "AB888X", + "63770": "AB888X", + "63771": "AB888X", + "63774": "AB888X", + "63775": "AB888X", + "63776": "AB888X", + "63778": "AB890X", + "63779": "AB890X", + "63780": "AB888X", + "63781": "AB888X", + "63782": "AB888X", + "63783": "AB888X", + "63784": "AB890X", + "63785": "AB888X", + "63787": "AB888X", + "63790": "AB890X", + "63801": "AB888X", + "63820": "AB888X", + "63821": "AB888X", + "63822": "AB888X", + "63823": "AB888X", + "63824": "AB888X", + "63825": "AB888X", + "63826": "AB888X", + "63827": "AB888X", + "63828": "AB888X", + "63829": "AB888X", + "63830": "AB888X", + "63833": "AB888X", + "63834": "AB888X", + "63837": "AB888X", + "63839": "AB888X", + "63840": "AB888X", + "63841": "AB888X", + "63845": "AB888X", + "63846": "AB888X", + "63847": "AB888X", + "63848": "AB888X", + "63849": "AB888X", + "63850": "AB888X", + "63851": "AB888X", + "63852": "AB888X", + "63853": "AB888X", + "63855": "AB888X", + "63857": "AB888X", + "63860": "AB888X", + "63862": "AB888X", + "63863": "AB888X", + "63866": "AB888X", + "63867": "AB888X", + "63868": "AB888X", + "63869": "AB888X", + "63870": "AB888X", + "63873": "AB888X", + "63874": "AB888X", + "63875": "AB888X", + "63876": "AB888X", + "63877": "AB888X", + "63878": "AB888X", + "63879": "AB888X", + "63880": "AB888X", + "63881": "AB888X", + "63882": "AB888X", + "63901": "AB888X", + "63902": "AB888X", + "63931": "AB888X", + "63932": "AB888X", + "63933": "AB888X", + "63934": "AB888X", + "63935": "AB888X", + "63936": "AB888X", + "63937": "AB888X", + "63938": "AB888X", + "63939": "AB888X", + "63940": "AB888X", + "63941": "AB888X", + "63942": "AB888X", + "63943": "AB888X", + "63944": "AB888X", + "63945": "AB888X", + "63950": "AB888X", + "63951": "AB888X", + "63952": "AB888X", + "63953": "AB888X", + "63954": "AB888X", + "63955": "AB888X", + "63956": "AB888X", + "63957": "AB888X", + "63960": "AB888X", + "63961": "AB888X", + "63962": "AB888X", + "63963": "AB888X", + "63964": "AB888X", + "63965": "AB888X", + "63966": "AB888X", + "63967": "AB888X", + "64001": "AB888X", + "64011": "AB888X", + "64012": "AB891X", + "64013": "AB888X", + "64014": "AB888X", + "64015": "AB888X", + "64016": "AB888X", + "64017": "AB888X", + "64018": "AB888X", + "64019": "AB888X", + "64020": "AB888X", + "64021": "AB888X", + "64022": "AB888X", + "64024": "AB888X", + "64028": "AB888X", + "64029": "AB888X", + "64030": "AB888X", + "64034": "AB888X", + "64035": "AB888X", + "64036": "AB888X", + "64037": "AB888X", + "64040": "AB888X", + "64048": "AB888X", + "64050": "AB888X", + "64051": "AB888X", + "64052": "AB888X", + "64053": "AB888X", + "64054": "AB888X", + "64055": "AB888X", + "64056": "AB888X", + "64057": "AB888X", + "64058": "AB888X", + "64060": "AB888X", + "64061": "AB888X", + "64062": "AB888X", + "64063": "AB888X", + "64064": "AB888X", + "64065": "AB888X", + "64066": "AB888X", + "64067": "AB888X", + "64068": "AB888X", + "64069": "AB888X", + "64070": "AB888X", + "64071": "AB888X", + "64072": "AB888X", + "64073": "AB888X", + "64074": "AB888X", + "64075": "AB888X", + "64076": "AB888X", + "64077": "AB888X", + "64078": "AB888X", + "64079": "AB888X", + "64080": "AB888X", + "64081": "AB888X", + "64082": "AB888X", + "64083": "AB888X", + "64084": "AB888X", + "64085": "AB888X", + "64086": "AB888X", + "64088": "AB888X", + "64089": "AB888X", + "64090": "AB888X", + "64092": "AB888X", + "64093": "AB888X", + "64096": "AB888X", + "64097": "AB888X", + "64098": "AB888X", + "64101": "AB888X", + "64102": "AB888X", + "64105": "AB888X", + "64106": "AB888X", + "64108": "AB888X", + "64109": "AB888X", + "64110": "AB888X", + "64111": "AB888X", + "64112": "AB888X", + "64113": "AB888X", + "64114": "AB888X", + "64116": "AB888X", + "64117": "AB888X", + "64118": "AB888X", + "64119": "AB888X", + "64120": "AB888X", + "64121": "AB888X", + "64123": "AB888X", + "64124": "AB888X", + "64125": "AB888X", + "64126": "AB888X", + "64127": "AB888X", + "64128": "AB888X", + "64129": "AB888X", + "64130": "AB888X", + "64131": "AB888X", + "64132": "AB888X", + "64133": "AB888X", + "64134": "AB888X", + "64136": "AB888X", + "64137": "AB888X", + "64138": "AB888X", + "64139": "AB888X", + "64141": "AB888X", + "64144": "AB888X", + "64145": "AB888X", + "64146": "AB888X", + "64147": "AB888X", + "64148": "AB888X", + "64149": "AB888X", + "64150": "AB888X", + "64151": "AB888X", + "64152": "AB888X", + "64153": "AB888X", + "64154": "AB888X", + "64155": "AB888X", + "64156": "AB888X", + "64157": "AB888X", + "64158": "AB888X", + "64161": "AB888X", + "64163": "AB888X", + "64164": "AB888X", + "64165": "AB888X", + "64166": "AB888X", + "64167": "AB888X", + "64168": "AB888X", + "64170": "AB888X", + "64171": "AB888X", + "64172": "AB888X", + "64179": "AB888X", + "64180": "AB888X", + "64183": "AB888X", + "64184": "AB888X", + "64185": "AB888X", + "64187": "AB888X", + "64188": "AB888X", + "64190": "AB888X", + "64191": "AB888X", + "64192": "AB888X", + "64193": "AB888X", + "64194": "AB888X", + "64195": "AB888X", + "64196": "AB888X", + "64197": "AB888X", + "64198": "AB888X", + "64199": "AB888X", + "64401": "AB888X", + "64402": "AB888X", + "64420": "AB888X", + "64421": "AB888X", + "64422": "AB888X", + "64423": "AB888X", + "64424": "AB888X", + "64425": "AB888X", + "64426": "AB888X", + "64427": "AB888X", + "64428": "AB888X", + "64429": "AB888X", + "64430": "AB888X", + "64431": "AB888X", + "64432": "AB888X", + "64433": "AB888X", + "64434": "AB888X", + "64436": "AB888X", + "64437": "AB888X", + "64438": "AB888X", + "64439": "AB888X", + "64440": "AB888X", + "64441": "AB888X", + "64442": "AB888X", + "64443": "AB888X", + "64444": "AB888X", + "64445": "AB888X", + "64446": "AB888X", + "64447": "AB888X", + "64448": "AB888X", + "64449": "AB888X", + "64451": "AB888X", + "64453": "AB888X", + "64454": "AB888X", + "64455": "AB888X", + "64456": "AB888X", + "64457": "AB888X", + "64458": "AB888X", + "64459": "AB888X", + "64461": "AB888X", + "64463": "AB888X", + "64465": "AB888X", + "64466": "AB888X", + "64467": "AB888X", + "64468": "AB888X", + "64469": "AB888X", + "64470": "AB888X", + "64471": "AB888X", + "64473": "AB888X", + "64474": "AB888X", + "64475": "AB888X", + "64476": "AB888X", + "64477": "AB888X", + "64479": "AB888X", + "64480": "AB888X", + "64481": "AB888X", + "64482": "AB888X", + "64483": "AB888X", + "64484": "AB888X", + "64485": "AB888X", + "64486": "AB888X", + "64487": "AB888X", + "64489": "AB888X", + "64490": "AB888X", + "64491": "AB888X", + "64492": "AB888X", + "64493": "AB888X", + "64494": "AB888X", + "64496": "AB888X", + "64497": "AB888X", + "64498": "AB888X", + "64499": "AB888X", + "64501": "AB888X", + "64502": "AB888X", + "64503": "AB888X", + "64504": "AB888X", + "64505": "AB888X", + "64506": "AB888X", + "64507": "AB888X", + "64508": "AB888X", + "64601": "AB888X", + "64620": "AB888X", + "64622": "AB888X", + "64623": "AB888X", + "64624": "AB888X", + "64625": "AB888X", + "64628": "AB888X", + "64630": "AB888X", + "64631": "AB888X", + "64632": "AB888X", + "64633": "AB888X", + "64635": "AB888X", + "64636": "AB888X", + "64637": "AB888X", + "64638": "AB888X", + "64639": "AB888X", + "64640": "AB888X", + "64641": "AB888X", + "64642": "AB888X", + "64643": "AB888X", + "64644": "AB888X", + "64645": "AB888X", + "64646": "AB888X", + "64647": "AB888X", + "64648": "AB888X", + "64649": "AB888X", + "64650": "AB888X", + "64651": "AB888X", + "64652": "AB888X", + "64653": "AB888X", + "64654": "AB888X", + "64655": "AB888X", + "64656": "AB888X", + "64657": "AB888X", + "64658": "AB888X", + "64659": "AB888X", + "64660": "AB888X", + "64661": "AB888X", + "64664": "AB888X", + "64667": "AB888X", + "64668": "AB888X", + "64670": "AB888X", + "64671": "AB888X", + "64672": "AB888X", + "64673": "AB888X", + "64674": "AB888X", + "64676": "AB888X", + "64679": "AB888X", + "64680": "AB888X", + "64681": "AB888X", + "64682": "AB888X", + "64683": "AB888X", + "64686": "AB888X", + "64688": "AB888X", + "64689": "AB888X", + "64701": "AB888X", + "64720": "AB888X", + "64722": "AB888X", + "64723": "AB888X", + "64724": "AB888X", + "64725": "AB888X", + "64726": "AB888X", + "64728": "AB890X", + "64730": "AB888X", + "64733": "AB888X", + "64734": "AB888X", + "64735": "AB888X", + "64738": "AB891X", + "64739": "AB888X", + "64740": "AB888X", + "64741": "AB890X", + "64742": "AB888X", + "64743": "AB888X", + "64744": "AB890X", + "64745": "AB888X", + "64746": "AB888X", + "64747": "AB888X", + "64748": "AB890X", + "64750": "AB890X", + "64752": "AB888X", + "64755": "AB890X", + "64756": "AB891X", + "64759": "AB890X", + "64761": "AB888X", + "64762": "AB890X", + "64763": "AB888X", + "64765": "AB890X", + "64766": "AB890X", + "64767": "AB890X", + "64769": "AB890X", + "64770": "AB888X", + "64771": "AB890X", + "64772": "AB890X", + "64776": "AB888X", + "64778": "AB890X", + "64779": "AB888X", + "64780": "AB888X", + "64781": "AB888X", + "64783": "AB890X", + "64784": "AB890X", + "64788": "AB888X", + "64789": "AB888X", + "64790": "AB890X", + "64801": "AB890X", + "64802": "AB890X", + "64803": "AB890X", + "64804": "AB890X", + "64830": "AB890X", + "64831": "AB890X", + "64832": "AB890X", + "64833": "AB890X", + "64834": "AB890X", + "64835": "AB890X", + "64836": "AB890X", + "64840": "AB890X", + "64841": "AB890X", + "64842": "AB890X", + "64843": "AB890X", + "64844": "AB890X", + "64847": "AB890X", + "64848": "AB891X", + "64849": "AB890X", + "64850": "AB890X", + "64853": "AB890X", + "64854": "AB890X", + "64855": "AB890X", + "64856": "AB890X", + "64857": "AB890X", + "64858": "AB890X", + "64859": "AB890X", + "64861": "AB890X", + "64862": "AB890X", + "64863": "AB890X", + "64864": "AB890X", + "64865": "AB890X", + "64866": "AB890X", + "64867": "AB890X", + "64868": "AB890X", + "64869": "AB890X", + "64870": "AB890X", + "64873": "AB890X", + "64874": "AB891X", + "64944": "AB888X", + "64999": "AB888X", + "65001": "AB888X", + "65010": "AB888X", + "65011": "AB888X", + "65013": "AB888X", + "65014": "AB888X", + "65016": "AB888X", + "65017": "AB891X", + "65018": "AB888X", + "65020": "AB891X", + "65023": "AB888X", + "65024": "AB888X", + "65025": "AB888X", + "65026": "AB891X", + "65032": "AB888X", + "65034": "AB888X", + "65035": "AB888X", + "65036": "AB888X", + "65037": "AB888X", + "65038": "AB891X", + "65039": "AB888X", + "65040": "AB891X", + "65041": "AB888X", + "65042": "AB888X", + "65043": "AB888X", + "65046": "AB888X", + "65047": "AB891X", + "65048": "AB888X", + "65049": "AB891X", + "65050": "AB888X", + "65051": "AB888X", + "65052": "AB891X", + "65053": "AB888X", + "65054": "AB888X", + "65055": "AB888X", + "65058": "AB888X", + "65059": "AB888X", + "65061": "AB888X", + "65062": "AB888X", + "65063": "AB888X", + "65064": "AB891X", + "65065": "AB891X", + "65066": "AB888X", + "65067": "AB888X", + "65068": "AB888X", + "65069": "AB888X", + "65072": "AB891X", + "65074": "AB888X", + "65075": "AB891X", + "65076": "AB888X", + "65077": "AB888X", + "65078": "AB888X", + "65079": "AB891X", + "65080": "AB888X", + "65081": "AB888X", + "65082": "AB891X", + "65083": "AB891X", + "65084": "AB888X", + "65085": "AB888X", + "65101": "AB888X", + "65102": "AB888X", + "65103": "AB888X", + "65104": "AB888X", + "65105": "AB888X", + "65106": "AB888X", + "65107": "AB888X", + "65108": "AB888X", + "65109": "AB888X", + "65110": "AB888X", + "65111": "AB888X", + "65201": "AB888X", + "65202": "AB888X", + "65203": "AB888X", + "65205": "AB888X", + "65211": "AB888X", + "65212": "AB888X", + "65215": "AB888X", + "65216": "AB888X", + "65217": "AB888X", + "65218": "AB888X", + "65230": "AB888X", + "65231": "AB888X", + "65232": "AB888X", + "65233": "AB888X", + "65236": "AB888X", + "65237": "AB888X", + "65239": "AB888X", + "65240": "AB888X", + "65243": "AB888X", + "65244": "AB888X", + "65246": "AB888X", + "65247": "AB888X", + "65248": "AB888X", + "65250": "AB888X", + "65251": "AB888X", + "65254": "AB888X", + "65255": "AB888X", + "65256": "AB888X", + "65257": "AB888X", + "65258": "AB888X", + "65259": "AB888X", + "65260": "AB888X", + "65261": "AB888X", + "65262": "AB888X", + "65263": "AB888X", + "65264": "AB888X", + "65265": "AB888X", + "65270": "AB888X", + "65274": "AB888X", + "65275": "AB888X", + "65276": "AB888X", + "65278": "AB888X", + "65279": "AB888X", + "65280": "AB888X", + "65281": "AB888X", + "65282": "AB888X", + "65283": "AB888X", + "65284": "AB888X", + "65285": "AB888X", + "65286": "AB888X", + "65287": "AB888X", + "65299": "AB888X", + "65301": "AB888X", + "65302": "AB888X", + "65305": "AB888X", + "65320": "AB888X", + "65321": "AB888X", + "65322": "AB888X", + "65323": "AB888X", + "65324": "AB891X", + "65325": "AB891X", + "65326": "AB891X", + "65327": "AB888X", + "65329": "AB888X", + "65330": "AB888X", + "65332": "AB888X", + "65333": "AB888X", + "65334": "AB888X", + "65335": "AB888X", + "65336": "AB888X", + "65337": "AB888X", + "65338": "AB891X", + "65339": "AB888X", + "65340": "AB888X", + "65344": "AB888X", + "65345": "AB888X", + "65347": "AB888X", + "65348": "AB888X", + "65349": "AB888X", + "65350": "AB888X", + "65351": "AB888X", + "65354": "AB888X", + "65355": "AB888X", + "65360": "AB888X", + "65401": "AB888X", + "65402": "AB888X", + "65409": "AB888X", + "65423": "AB891X", + "65436": "AB888X", + "65438": "AB891X", + "65439": "AB888X", + "65440": "AB888X", + "65441": "AB888X", + "65443": "AB888X", + "65444": "AB891X", + "65446": "AB888X", + "65449": "AB888X", + "65452": "AB891X", + "65453": "AB888X", + "65456": "AB888X", + "65457": "AB891X", + "65459": "AB891X", + "65461": "AB888X", + "65462": "AB888X", + "65463": "AB891X", + "65464": "AB891X", + "65466": "AB891X", + "65468": "AB891X", + "65470": "AB891X", + "65473": "AB891X", + "65479": "AB891X", + "65483": "AB891X", + "65484": "AB891X", + "65486": "AB891X", + "65501": "AB888X", + "65529": "AB891X", + "65532": "AB888X", + "65534": "AB891X", + "65535": "AB888X", + "65536": "AB891X", + "65541": "AB888X", + "65542": "AB891X", + "65543": "AB891X", + "65546": "AB891X", + "65548": "AB891X", + "65550": "AB888X", + "65552": "AB891X", + "65555": "AB891X", + "65556": "AB891X", + "65557": "AB891X", + "65559": "AB888X", + "65560": "AB888X", + "65564": "AB891X", + "65565": "AB888X", + "65566": "AB888X", + "65567": "AB891X", + "65570": "AB891X", + "65571": "AB891X", + "65580": "AB888X", + "65582": "AB888X", + "65583": "AB891X", + "65584": "AB891X", + "65586": "AB888X", + "65588": "AB891X", + "65589": "AB891X", + "65590": "AB891X", + "65591": "AB891X", + "65601": "AB891X", + "65603": "AB891X", + "65604": "AB891X", + "65605": "AB891X", + "65606": "AB891X", + "65607": "AB891X", + "65608": "AB891X", + "65609": "AB891X", + "65610": "AB891X", + "65611": "AB891X", + "65612": "AB891X", + "65613": "AB891X", + "65614": "AB891X", + "65615": "AB891X", + "65616": "AB891X", + "65617": "AB891X", + "65618": "AB891X", + "65619": "AB891X", + "65620": "AB891X", + "65622": "AB891X", + "65623": "AB891X", + "65624": "AB891X", + "65625": "AB891X", + "65626": "AB891X", + "65627": "AB891X", + "65629": "AB891X", + "65630": "AB891X", + "65631": "AB891X", + "65632": "AB891X", + "65633": "AB891X", + "65634": "AB891X", + "65635": "AB891X", + "65636": "AB891X", + "65637": "AB891X", + "65638": "AB891X", + "65640": "AB891X", + "65641": "AB891X", + "65644": "AB891X", + "65645": "AB891X", + "65646": "AB891X", + "65647": "AB891X", + "65648": "AB891X", + "65649": "AB891X", + "65650": "AB891X", + "65652": "AB891X", + "65653": "AB891X", + "65654": "AB891X", + "65655": "AB891X", + "65656": "AB891X", + "65657": "AB891X", + "65658": "AB891X", + "65660": "AB891X", + "65661": "AB891X", + "65662": "AB891X", + "65663": "AB891X", + "65664": "AB891X", + "65666": "AB891X", + "65667": "AB891X", + "65668": "AB891X", + "65669": "AB891X", + "65672": "AB891X", + "65673": "AB891X", + "65674": "AB891X", + "65675": "AB891X", + "65676": "AB891X", + "65679": "AB891X", + "65680": "AB891X", + "65681": "AB891X", + "65682": "AB890X", + "65685": "AB891X", + "65686": "AB891X", + "65688": "AB891X", + "65689": "AB891X", + "65690": "AB891X", + "65692": "AB891X", + "65701": "AB891X", + "65702": "AB891X", + "65704": "AB891X", + "65705": "AB891X", + "65706": "AB891X", + "65707": "AB891X", + "65708": "AB891X", + "65710": "AB891X", + "65711": "AB891X", + "65712": "AB891X", + "65713": "AB891X", + "65714": "AB891X", + "65715": "AB891X", + "65717": "AB891X", + "65720": "AB891X", + "65721": "AB891X", + "65722": "AB891X", + "65723": "AB890X", + "65724": "AB891X", + "65725": "AB891X", + "65726": "AB891X", + "65727": "AB891X", + "65728": "AB891X", + "65729": "AB891X", + "65730": "AB890X", + "65731": "AB891X", + "65732": "AB891X", + "65733": "AB891X", + "65734": "AB891X", + "65735": "AB891X", + "65737": "AB891X", + "65738": "AB891X", + "65739": "AB891X", + "65740": "AB891X", + "65741": "AB891X", + "65742": "AB891X", + "65744": "AB891X", + "65745": "AB891X", + "65746": "AB891X", + "65747": "AB891X", + "65752": "AB891X", + "65753": "AB891X", + "65754": "AB891X", + "65755": "AB891X", + "65756": "AB891X", + "65757": "AB891X", + "65759": "AB891X", + "65760": "AB891X", + "65761": "AB891X", + "65762": "AB891X", + "65764": "AB891X", + "65765": "AB891X", + "65766": "AB891X", + "65767": "AB891X", + "65768": "AB891X", + "65769": "AB891X", + "65770": "AB891X", + "65771": "AB891X", + "65772": "AB891X", + "65773": "AB891X", + "65774": "AB891X", + "65775": "AB891X", + "65776": "AB891X", + "65777": "AB887X", + "65778": "AB891X", + "65779": "AB891X", + "65781": "AB891X", + "65783": "AB891X", + "65784": "AB891X", + "65785": "AB891X", + "65786": "AB891X", + "65787": "AB891X", + "65788": "AB891X", + "65789": "AB891X", + "65790": "AB891X", + "65791": "AB891X", + "65793": "AB891X", + "65801": "AB891X", + "65802": "AB891X", + "65803": "AB891X", + "65804": "AB891X", + "65805": "AB891X", + "65806": "AB891X", + "65807": "AB891X", + "65808": "AB891X", + "65809": "AB891X", + "65810": "AB891X", + "65814": "AB891X", + "65817": "AB891X", + "65842": "AB891X", + "65875": "AB891X", + "65890": "AB891X", + "65897": "AB891X", + "65898": "AB891X", + "65899": "AB891X", + "66002": "AB888X", + "66006": "AB888X", + "66007": "AB888X", + "66008": "AB888X", + "66010": "AB888X", + "66012": "AB888X", + "66013": "AB888X", + "66014": "AB888X", + "66015": "AB890X", + "66016": "AB888X", + "66017": "AB888X", + "66018": "AB888X", + "66019": "AB888X", + "66020": "AB888X", + "66021": "AB888X", + "66023": "AB888X", + "66024": "AB888X", + "66025": "AB888X", + "66026": "AB888X", + "66027": "AB888X", + "66030": "AB888X", + "66031": "AB888X", + "66032": "AB888X", + "66033": "AB888X", + "66035": "AB888X", + "66036": "AB888X", + "66039": "AB890X", + "66040": "AB888X", + "66041": "AB888X", + "66042": "AB888X", + "66043": "AB888X", + "66044": "AB888X", + "66045": "AB888X", + "66046": "AB888X", + "66047": "AB888X", + "66048": "AB888X", + "66049": "AB888X", + "66050": "AB888X", + "66051": "AB888X", + "66052": "AB888X", + "66053": "AB888X", + "66054": "AB888X", + "66056": "AB888X", + "66058": "AB888X", + "66060": "AB888X", + "66061": "AB888X", + "66062": "AB888X", + "66063": "AB888X", + "66064": "AB888X", + "66066": "AB888X", + "66067": "AB888X", + "66070": "AB888X", + "66071": "AB888X", + "66072": "AB888X", + "66073": "AB888X", + "66075": "AB888X", + "66076": "AB888X", + "66077": "AB888X", + "66078": "AB888X", + "66079": "AB888X", + "66080": "AB888X", + "66083": "AB888X", + "66085": "AB888X", + "66086": "AB888X", + "66087": "AB888X", + "66088": "AB888X", + "66090": "AB888X", + "66091": "AB890X", + "66092": "AB888X", + "66093": "AB890X", + "66094": "AB888X", + "66095": "AB888X", + "66097": "AB888X", + "66101": "AB888X", + "66102": "AB888X", + "66103": "AB888X", + "66104": "AB888X", + "66105": "AB888X", + "66106": "AB888X", + "66109": "AB888X", + "66110": "AB888X", + "66111": "AB888X", + "66112": "AB888X", + "66113": "AB888X", + "66115": "AB888X", + "66117": "AB888X", + "66118": "AB888X", + "66119": "AB888X", + "66160": "AB888X", + "66201": "AB888X", + "66202": "AB888X", + "66203": "AB888X", + "66204": "AB888X", + "66205": "AB888X", + "66206": "AB888X", + "66207": "AB888X", + "66208": "AB888X", + "66209": "AB888X", + "66210": "AB888X", + "66211": "AB888X", + "66212": "AB888X", + "66213": "AB888X", + "66214": "AB888X", + "66215": "AB888X", + "66216": "AB888X", + "66217": "AB888X", + "66218": "AB888X", + "66219": "AB888X", + "66220": "AB888X", + "66221": "AB888X", + "66222": "AB888X", + "66223": "AB888X", + "66224": "AB888X", + "66225": "AB888X", + "66226": "AB888X", + "66227": "AB888X", + "66250": "AB888X", + "66251": "AB888X", + "66276": "AB888X", + "66279": "AB888X", + "66282": "AB888X", + "66283": "AB888X", + "66285": "AB888X", + "66286": "AB888X", + "66401": "AB888X", + "66402": "AB888X", + "66403": "AB888X", + "66404": "AB888X", + "66406": "AB888X", + "66407": "AB888X", + "66408": "AB888X", + "66409": "AB888X", + "66411": "AB888X", + "66412": "AB888X", + "66413": "AB888X", + "66414": "AB888X", + "66415": "AB888X", + "66416": "AB888X", + "66417": "AB888X", + "66418": "AB888X", + "66419": "AB888X", + "66420": "AB888X", + "66422": "AB888X", + "66423": "AB888X", + "66424": "AB888X", + "66425": "AB888X", + "66426": "AB888X", + "66427": "AB888X", + "66428": "AB888X", + "66429": "AB888X", + "66431": "AB888X", + "66432": "AB888X", + "66434": "AB888X", + "66436": "AB888X", + "66438": "AB888X", + "66439": "AB888X", + "66440": "AB888X", + "66441": "AB888X", + "66442": "AB888X", + "66449": "AB888X", + "66451": "AB888X", + "66501": "AB888X", + "66502": "AB888X", + "66503": "AB888X", + "66505": "AB888X", + "66506": "AB888X", + "66507": "AB888X", + "66508": "AB888X", + "66509": "AB888X", + "66510": "AB888X", + "66512": "AB888X", + "66514": "AB888X", + "66515": "AB888X", + "66516": "AB888X", + "66517": "AB888X", + "66518": "AB888X", + "66520": "AB888X", + "66521": "AB888X", + "66522": "AB888X", + "66523": "AB888X", + "66524": "AB888X", + "66526": "AB888X", + "66527": "AB888X", + "66528": "AB888X", + "66531": "AB888X", + "66532": "AB888X", + "66533": "AB888X", + "66534": "AB888X", + "66535": "AB888X", + "66536": "AB888X", + "66537": "AB888X", + "66538": "AB888X", + "66539": "AB888X", + "66540": "AB888X", + "66541": "AB888X", + "66542": "AB888X", + "66543": "AB888X", + "66544": "AB888X", + "66546": "AB888X", + "66547": "AB888X", + "66548": "AB888X", + "66549": "AB888X", + "66550": "AB888X", + "66552": "AB888X", + "66554": "AB888X", + "66601": "AB888X", + "66603": "AB888X", + "66604": "AB888X", + "66605": "AB888X", + "66606": "AB888X", + "66607": "AB888X", + "66608": "AB888X", + "66609": "AB888X", + "66610": "AB888X", + "66611": "AB888X", + "66612": "AB888X", + "66614": "AB888X", + "66615": "AB888X", + "66616": "AB888X", + "66617": "AB888X", + "66618": "AB888X", + "66619": "AB888X", + "66620": "AB888X", + "66621": "AB888X", + "66622": "AB888X", + "66624": "AB888X", + "66625": "AB888X", + "66626": "AB888X", + "66628": "AB888X", + "66629": "AB888X", + "66636": "AB888X", + "66637": "AB888X", + "66642": "AB888X", + "66647": "AB888X", + "66652": "AB888X", + "66653": "AB888X", + "66667": "AB888X", + "66675": "AB888X", + "66683": "AB888X", + "66692": "AB888X", + "66699": "AB888X", + "66701": "AB888X", + "66710": "AB888X", + "66711": "AB888X", + "66712": "AB888X", + "66713": "AB888X", + "66714": "AB888X", + "66716": "AB888X", + "66717": "AB888X", + "66720": "AB888X", + "66724": "AB888X", + "66725": "AB888X", + "66728": "AB888X", + "66732": "AB888X", + "66733": "AB888X", + "66734": "AB888X", + "66735": "AB888X", + "66736": "AB888X", + "66738": "AB888X", + "66739": "AB888X", + "66740": "AB888X", + "66741": "AB888X", + "66742": "AB888X", + "66743": "AB888X", + "66746": "AB888X", + "66748": "AB888X", + "66749": "AB888X", + "66751": "AB888X", + "66753": "AB888X", + "66754": "AB888X", + "66755": "AB888X", + "66756": "AB888X", + "66757": "AB888X", + "66758": "AB888X", + "66759": "AB888X", + "66760": "AB888X", + "66761": "AB888X", + "66762": "AB888X", + "66763": "AB888X", + "66767": "AB888X", + "66769": "AB888X", + "66770": "AB888X", + "66771": "AB888X", + "66772": "AB888X", + "66773": "AB888X", + "66775": "AB888X", + "66776": "AB888X", + "66777": "AB888X", + "66778": "AB888X", + "66779": "AB888X", + "66780": "AB888X", + "66781": "AB888X", + "66782": "AB888X", + "66783": "AB888X", + "66801": "AB888X", + "66830": "AB888X", + "66833": "AB888X", + "66834": "AB888X", + "66835": "AB888X", + "66838": "AB888X", + "66839": "AB888X", + "66840": "AB888X", + "66842": "AB888X", + "66843": "AB888X", + "66845": "AB888X", + "66846": "AB888X", + "66849": "AB888X", + "66850": "AB888X", + "66851": "AB888X", + "66852": "AB888X", + "66853": "AB888X", + "66854": "AB888X", + "66855": "AB888X", + "66856": "AB888X", + "66857": "AB888X", + "66858": "AB888X", + "66859": "AB888X", + "66860": "AB888X", + "66861": "AB888X", + "66862": "AB888X", + "66863": "AB888X", + "66864": "AB888X", + "66865": "AB888X", + "66866": "AB888X", + "66868": "AB888X", + "66869": "AB888X", + "66870": "AB888X", + "66871": "AB888X", + "66872": "AB888X", + "66873": "AB888X", + "66901": "AB888X", + "66930": "AB889X", + "66932": "AB889X", + "66933": "AB889X", + "66935": "AB889X", + "66936": "AB889X", + "66937": "AB889X", + "66938": "AB888X", + "66939": "AB889X", + "66940": "AB889X", + "66941": "AB889X", + "66942": "AB889X", + "66943": "AB889X", + "66944": "AB889X", + "66945": "AB889X", + "66946": "AB889X", + "66948": "AB888X", + "66949": "AB889X", + "66951": "AB889X", + "66952": "AB889X", + "66953": "AB889X", + "66955": "AB889X", + "66956": "AB889X", + "66958": "AB889X", + "66959": "AB889X", + "66960": "AB889X", + "66961": "AB889X", + "66962": "AB889X", + "66963": "AB889X", + "66964": "AB889X", + "66966": "AB889X", + "66967": "AB889X", + "66968": "AB889X", + "66970": "AB889X", + "67001": "AB888X", + "67002": "AB888X", + "67003": "AB888X", + "67004": "AB888X", + "67005": "AB888X", + "67008": "AB888X", + "67009": "AB888X", + "67010": "AB888X", + "67012": "AB888X", + "67013": "AB888X", + "67016": "AB888X", + "67017": "AB888X", + "67018": "AB888X", + "67019": "AB888X", + "67020": "AB888X", + "67021": "AB888X", + "67022": "AB888X", + "67023": "AB888X", + "67024": "AB888X", + "67025": "AB888X", + "67026": "AB888X", + "67028": "AB888X", + "67029": "AB888X", + "67030": "AB888X", + "67031": "AB888X", + "67035": "AB888X", + "67036": "AB888X", + "67037": "AB888X", + "67038": "AB888X", + "67039": "AB888X", + "67041": "AB888X", + "67042": "AB888X", + "67045": "AB888X", + "67047": "AB888X", + "67049": "AB888X", + "67050": "AB888X", + "67051": "AB888X", + "67052": "AB888X", + "67053": "AB888X", + "67054": "AB888X", + "67055": "AB888X", + "67056": "AB888X", + "67057": "AB888X", + "67058": "AB888X", + "67059": "AB888X", + "67060": "AB888X", + "67061": "AB888X", + "67062": "AB888X", + "67063": "AB888X", + "67065": "AB888X", + "67066": "AB888X", + "67067": "AB888X", + "67068": "AB888X", + "67070": "AB888X", + "67071": "AB888X", + "67072": "AB888X", + "67073": "AB888X", + "67074": "AB888X", + "67101": "AB888X", + "67102": "AB888X", + "67103": "AB888X", + "67104": "AB888X", + "67105": "AB888X", + "67106": "AB888X", + "67107": "AB888X", + "67108": "AB888X", + "67109": "AB888X", + "67110": "AB888X", + "67111": "AB888X", + "67112": "AB888X", + "67114": "AB888X", + "67117": "AB888X", + "67118": "AB888X", + "67119": "AB888X", + "67120": "AB888X", + "67122": "AB888X", + "67123": "AB888X", + "67124": "AB888X", + "67127": "AB888X", + "67131": "AB888X", + "67132": "AB888X", + "67133": "AB888X", + "67134": "AB888X", + "67135": "AB888X", + "67137": "AB888X", + "67138": "AB888X", + "67140": "AB888X", + "67142": "AB888X", + "67143": "AB888X", + "67144": "AB888X", + "67146": "AB888X", + "67147": "AB888X", + "67149": "AB888X", + "67150": "AB888X", + "67151": "AB888X", + "67152": "AB888X", + "67154": "AB888X", + "67155": "AB888X", + "67156": "AB888X", + "67159": "AB888X", + "67201": "AB888X", + "67202": "AB888X", + "67203": "AB888X", + "67204": "AB888X", + "67205": "AB888X", + "67206": "AB888X", + "67207": "AB888X", + "67208": "AB888X", + "67209": "AB888X", + "67210": "AB888X", + "67211": "AB888X", + "67212": "AB888X", + "67213": "AB888X", + "67214": "AB888X", + "67215": "AB888X", + "67216": "AB888X", + "67217": "AB888X", + "67218": "AB888X", + "67219": "AB888X", + "67220": "AB888X", + "67221": "AB888X", + "67223": "AB888X", + "67226": "AB888X", + "67227": "AB888X", + "67228": "AB888X", + "67230": "AB888X", + "67231": "AB888X", + "67232": "AB888X", + "67235": "AB888X", + "67260": "AB888X", + "67275": "AB888X", + "67276": "AB888X", + "67277": "AB888X", + "67278": "AB888X", + "67301": "AB890X", + "67330": "AB888X", + "67332": "AB888X", + "67333": "AB890X", + "67334": "AB888X", + "67335": "AB890X", + "67336": "AB888X", + "67337": "AB890X", + "67340": "AB890X", + "67341": "AB888X", + "67342": "AB888X", + "67344": "AB890X", + "67345": "AB888X", + "67346": "AB888X", + "67347": "AB890X", + "67349": "AB888X", + "67351": "AB890X", + "67352": "AB888X", + "67353": "AB888X", + "67354": "AB888X", + "67355": "AB888X", + "67356": "AB888X", + "67357": "AB888X", + "67360": "AB888X", + "67361": "AB888X", + "67363": "AB890X", + "67364": "AB890X", + "67401": "AB888X", + "67402": "AB888X", + "67410": "AB888X", + "67416": "AB888X", + "67417": "AB888X", + "67418": "AB888X", + "67420": "AB888X", + "67422": "AB888X", + "67423": "AB888X", + "67425": "AB888X", + "67427": "AB888X", + "67428": "AB888X", + "67430": "AB888X", + "67431": "AB888X", + "67432": "AB888X", + "67436": "AB888X", + "67437": "AB888X", + "67438": "AB888X", + "67439": "AB888X", + "67441": "AB888X", + "67442": "AB888X", + "67443": "AB888X", + "67444": "AB888X", + "67445": "AB888X", + "67446": "AB888X", + "67447": "AB888X", + "67448": "AB888X", + "67449": "AB888X", + "67450": "AB888X", + "67451": "AB888X", + "67452": "AB888X", + "67454": "AB888X", + "67455": "AB888X", + "67456": "AB888X", + "67457": "AB888X", + "67458": "AB888X", + "67459": "AB888X", + "67460": "AB888X", + "67464": "AB888X", + "67466": "AB888X", + "67467": "AB888X", + "67468": "AB888X", + "67470": "AB888X", + "67473": "AB888X", + "67474": "AB888X", + "67475": "AB888X", + "67476": "AB888X", + "67478": "AB888X", + "67480": "AB888X", + "67481": "AB888X", + "67482": "AB888X", + "67483": "AB888X", + "67484": "AB888X", + "67485": "AB888X", + "67487": "AB888X", + "67490": "AB888X", + "67491": "AB888X", + "67492": "AB888X", + "67501": "AB888X", + "67502": "AB888X", + "67504": "AB888X", + "67505": "AB888X", + "67510": "AB888X", + "67511": "AB888X", + "67512": "AB888X", + "67513": "AB888X", + "67514": "AB888X", + "67515": "AB888X", + "67516": "AB888X", + "67518": "AB888X", + "67519": "AB888X", + "67520": "AB888X", + "67521": "AB888X", + "67522": "AB888X", + "67523": "AB888X", + "67524": "AB888X", + "67525": "AB888X", + "67526": "AB888X", + "67529": "AB888X", + "67530": "AB888X", + "67543": "AB888X", + "67544": "AB888X", + "67545": "AB888X", + "67546": "AB888X", + "67547": "AB888X", + "67548": "AB888X", + "67550": "AB888X", + "67552": "AB888X", + "67553": "AB888X", + "67554": "AB888X", + "67556": "AB888X", + "67557": "AB888X", + "67559": "AB888X", + "67560": "AB888X", + "67561": "AB888X", + "67563": "AB888X", + "67564": "AB888X", + "67565": "AB888X", + "67566": "AB888X", + "67567": "AB888X", + "67568": "AB888X", + "67570": "AB888X", + "67572": "AB888X", + "67573": "AB888X", + "67574": "AB888X", + "67575": "AB888X", + "67576": "AB888X", + "67578": "AB888X", + "67579": "AB888X", + "67581": "AB888X", + "67583": "AB888X", + "67584": "AB888X", + "67585": "AB888X", + "67601": "AB888X", + "67621": "AB888X", + "67622": "AB888X", + "67623": "AB888X", + "67625": "AB888X", + "67626": "AB888X", + "67627": "AB888X", + "67628": "AB889X", + "67629": "AB888X", + "67631": "AB888X", + "67632": "AB888X", + "67634": "AB888X", + "67635": "AB888X", + "67637": "AB888X", + "67638": "AB889X", + "67639": "AB888X", + "67640": "AB888X", + "67642": "AB888X", + "67643": "AB888X", + "67644": "AB888X", + "67645": "AB888X", + "67646": "AB888X", + "67647": "AB888X", + "67648": "AB888X", + "67649": "AB888X", + "67650": "AB888X", + "67651": "AB888X", + "67653": "AB888X", + "67654": "AB888X", + "67656": "AB888X", + "67657": "AB888X", + "67658": "AB888X", + "67659": "AB888X", + "67660": "AB888X", + "67661": "AB888X", + "67663": "AB888X", + "67664": "AB888X", + "67665": "AB888X", + "67667": "AB888X", + "67669": "AB888X", + "67671": "AB888X", + "67672": "AB888X", + "67673": "AB888X", + "67674": "AB888X", + "67675": "AB888X", + "67701": "AB888X", + "67730": "AB888X", + "67731": "AB888X", + "67732": "AB888X", + "67733": "AB888X", + "67734": "AB888X", + "67735": "AB888X", + "67736": "AB888X", + "67737": "AB888X", + "67738": "AB888X", + "67739": "AB888X", + "67740": "AB888X", + "67741": "AB888X", + "67743": "AB888X", + "67744": "AB888X", + "67745": "AB888X", + "67747": "AB888X", + "67748": "AB888X", + "67749": "AB888X", + "67751": "AB888X", + "67752": "AB888X", + "67753": "AB888X", + "67756": "AB888X", + "67757": "AB888X", + "67758": "AB888X", + "67761": "AB888X", + "67762": "AB888X", + "67764": "AB888X", + "67801": "AB888X", + "67831": "AB888X", + "67834": "AB888X", + "67835": "AB888X", + "67836": "AB888X", + "67837": "AB888X", + "67838": "AB888X", + "67839": "AB888X", + "67840": "AB888X", + "67841": "AB888X", + "67842": "AB888X", + "67843": "AB888X", + "67844": "AB888X", + "67846": "AB888X", + "67849": "AB888X", + "67850": "AB888X", + "67851": "AB888X", + "67853": "AB888X", + "67854": "AB888X", + "67855": "AB888X", + "67857": "AB888X", + "67859": "AB888X", + "67860": "AB888X", + "67861": "AB888X", + "67862": "AB888X", + "67863": "AB888X", + "67864": "AB888X", + "67865": "AB888X", + "67867": "AB888X", + "67868": "AB888X", + "67869": "AB888X", + "67870": "AB888X", + "67871": "AB888X", + "67876": "AB888X", + "67877": "AB888X", + "67878": "AB888X", + "67879": "AB888X", + "67880": "AB888X", + "67882": "AB888X", + "67901": "AB888X", + "67905": "AB888X", + "67950": "AB888X", + "67951": "AB888X", + "67952": "AB888X", + "67953": "AB888X", + "67954": "AB888X", + "68001": "AB889X", + "68002": "AB889X", + "68003": "AB889X", + "68004": "AB891X", + "68005": "AB889X", + "68007": "AB889X", + "68008": "AB889X", + "68009": "AB889X", + "68010": "AB889X", + "68014": "AB889X", + "68015": "AB889X", + "68016": "AB889X", + "68017": "AB889X", + "68018": "AB889X", + "68019": "AB891X", + "68020": "AB891X", + "68022": "AB889X", + "68023": "AB889X", + "68025": "AB889X", + "68026": "AB889X", + "68028": "AB889X", + "68029": "AB889X", + "68030": "AB891X", + "68031": "AB889X", + "68033": "AB889X", + "68034": "AB889X", + "68036": "AB889X", + "68037": "AB889X", + "68038": "AB891X", + "68039": "AB889X", + "68040": "AB889X", + "68041": "AB889X", + "68042": "AB889X", + "68044": "AB889X", + "68045": "AB891X", + "68046": "AB889X", + "68047": "AB891X", + "68048": "AB889X", + "68050": "AB889X", + "68055": "AB889X", + "68056": "AB889X", + "68057": "AB889X", + "68058": "AB889X", + "68059": "AB889X", + "68061": "AB889X", + "68062": "AB889X", + "68063": "AB889X", + "68064": "AB889X", + "68065": "AB889X", + "68066": "AB889X", + "68067": "AB891X", + "68068": "AB889X", + "68069": "AB889X", + "68070": "AB889X", + "68071": "AB891X", + "68072": "AB889X", + "68073": "AB889X", + "68101": "AB889X", + "68102": "AB889X", + "68103": "AB889X", + "68104": "AB889X", + "68105": "AB889X", + "68106": "AB889X", + "68107": "AB889X", + "68108": "AB889X", + "68109": "AB889X", + "68110": "AB889X", + "68111": "AB889X", + "68112": "AB889X", + "68113": "AB889X", + "68114": "AB889X", + "68116": "AB889X", + "68117": "AB889X", + "68118": "AB889X", + "68119": "AB889X", + "68120": "AB889X", + "68122": "AB889X", + "68123": "AB889X", + "68124": "AB889X", + "68127": "AB889X", + "68128": "AB889X", + "68130": "AB889X", + "68131": "AB889X", + "68132": "AB889X", + "68133": "AB889X", + "68134": "AB889X", + "68135": "AB889X", + "68136": "AB889X", + "68137": "AB889X", + "68138": "AB889X", + "68139": "AB889X", + "68142": "AB889X", + "68144": "AB889X", + "68145": "AB889X", + "68147": "AB889X", + "68152": "AB889X", + "68154": "AB889X", + "68155": "AB889X", + "68157": "AB889X", + "68164": "AB889X", + "68172": "AB889X", + "68175": "AB889X", + "68176": "AB889X", + "68178": "AB889X", + "68179": "AB889X", + "68180": "AB889X", + "68181": "AB889X", + "68182": "AB889X", + "68183": "AB889X", + "68197": "AB889X", + "68198": "AB889X", + "68301": "AB889X", + "68303": "AB889X", + "68304": "AB889X", + "68305": "AB889X", + "68307": "AB889X", + "68309": "AB889X", + "68310": "AB889X", + "68313": "AB889X", + "68314": "AB889X", + "68315": "AB889X", + "68316": "AB889X", + "68317": "AB889X", + "68318": "AB889X", + "68319": "AB889X", + "68320": "AB889X", + "68321": "AB889X", + "68322": "AB889X", + "68323": "AB889X", + "68324": "AB889X", + "68325": "AB889X", + "68326": "AB889X", + "68327": "AB889X", + "68328": "AB889X", + "68329": "AB889X", + "68330": "AB889X", + "68331": "AB889X", + "68332": "AB889X", + "68333": "AB889X", + "68335": "AB889X", + "68336": "AB889X", + "68337": "AB889X", + "68338": "AB889X", + "68339": "AB889X", + "68340": "AB889X", + "68341": "AB889X", + "68342": "AB889X", + "68343": "AB889X", + "68344": "AB889X", + "68345": "AB889X", + "68346": "AB889X", + "68347": "AB889X", + "68348": "AB889X", + "68349": "AB889X", + "68350": "AB889X", + "68351": "AB889X", + "68352": "AB889X", + "68354": "AB889X", + "68355": "AB889X", + "68357": "AB889X", + "68358": "AB889X", + "68359": "AB889X", + "68360": "AB889X", + "68361": "AB889X", + "68362": "AB889X", + "68364": "AB889X", + "68365": "AB889X", + "68366": "AB889X", + "68367": "AB889X", + "68368": "AB889X", + "68370": "AB889X", + "68371": "AB889X", + "68372": "AB889X", + "68375": "AB889X", + "68376": "AB889X", + "68377": "AB889X", + "68378": "AB889X", + "68379": "AB889X", + "68380": "AB889X", + "68381": "AB889X", + "68382": "AB889X", + "68401": "AB889X", + "68402": "AB889X", + "68403": "AB889X", + "68404": "AB889X", + "68405": "AB889X", + "68406": "AB889X", + "68407": "AB889X", + "68409": "AB889X", + "68410": "AB889X", + "68413": "AB889X", + "68414": "AB889X", + "68415": "AB889X", + "68416": "AB889X", + "68417": "AB889X", + "68418": "AB889X", + "68419": "AB889X", + "68420": "AB889X", + "68421": "AB889X", + "68422": "AB889X", + "68423": "AB889X", + "68424": "AB889X", + "68428": "AB889X", + "68429": "AB889X", + "68430": "AB889X", + "68431": "AB889X", + "68433": "AB889X", + "68434": "AB889X", + "68436": "AB889X", + "68437": "AB889X", + "68438": "AB889X", + "68439": "AB889X", + "68440": "AB889X", + "68441": "AB889X", + "68442": "AB889X", + "68443": "AB889X", + "68444": "AB889X", + "68445": "AB889X", + "68446": "AB889X", + "68447": "AB889X", + "68448": "AB889X", + "68450": "AB889X", + "68452": "AB889X", + "68453": "AB889X", + "68454": "AB889X", + "68455": "AB889X", + "68456": "AB889X", + "68457": "AB889X", + "68458": "AB889X", + "68460": "AB889X", + "68461": "AB889X", + "68462": "AB889X", + "68463": "AB889X", + "68464": "AB889X", + "68465": "AB889X", + "68466": "AB889X", + "68467": "AB889X", + "68501": "AB889X", + "68502": "AB889X", + "68503": "AB889X", + "68504": "AB889X", + "68505": "AB889X", + "68506": "AB889X", + "68507": "AB889X", + "68508": "AB889X", + "68509": "AB889X", + "68510": "AB889X", + "68512": "AB889X", + "68514": "AB889X", + "68516": "AB889X", + "68517": "AB889X", + "68520": "AB889X", + "68521": "AB889X", + "68522": "AB889X", + "68523": "AB889X", + "68524": "AB889X", + "68526": "AB889X", + "68527": "AB889X", + "68528": "AB889X", + "68529": "AB889X", + "68531": "AB889X", + "68532": "AB889X", + "68542": "AB889X", + "68583": "AB889X", + "68588": "AB889X", + "68601": "AB889X", + "68602": "AB889X", + "68620": "AB889X", + "68621": "AB889X", + "68622": "AB889X", + "68623": "AB889X", + "68624": "AB889X", + "68626": "AB889X", + "68627": "AB889X", + "68628": "AB889X", + "68629": "AB889X", + "68631": "AB889X", + "68632": "AB889X", + "68633": "AB889X", + "68634": "AB889X", + "68635": "AB889X", + "68636": "AB889X", + "68637": "AB889X", + "68638": "AB889X", + "68640": "AB889X", + "68641": "AB889X", + "68642": "AB889X", + "68643": "AB889X", + "68644": "AB889X", + "68647": "AB889X", + "68648": "AB889X", + "68649": "AB889X", + "68651": "AB889X", + "68652": "AB889X", + "68653": "AB889X", + "68654": "AB889X", + "68655": "AB889X", + "68658": "AB889X", + "68659": "AB889X", + "68660": "AB889X", + "68661": "AB889X", + "68662": "AB889X", + "68663": "AB889X", + "68664": "AB889X", + "68665": "AB889X", + "68666": "AB889X", + "68667": "AB889X", + "68669": "AB889X", + "68701": "AB891X", + "68702": "AB889X", + "68710": "AB891X", + "68711": "AB889X", + "68713": "AB889X", + "68714": "AB889X", + "68715": "AB889X", + "68716": "AB889X", + "68717": "AB889X", + "68718": "AB889X", + "68719": "AB889X", + "68720": "AB889X", + "68722": "AB889X", + "68723": "AB889X", + "68724": "AB889X", + "68725": "AB889X", + "68726": "AB889X", + "68727": "AB889X", + "68728": "AB889X", + "68729": "AB889X", + "68730": "AB889X", + "68731": "AB891X", + "68732": "AB889X", + "68733": "AB891X", + "68734": "AB889X", + "68735": "AB889X", + "68736": "AB889X", + "68738": "AB889X", + "68739": "AB891X", + "68740": "AB889X", + "68741": "AB891X", + "68742": "AB889X", + "68743": "AB891X", + "68745": "AB891X", + "68746": "AB889X", + "68747": "AB889X", + "68748": "AB889X", + "68749": "AB889X", + "68751": "AB889X", + "68752": "AB889X", + "68753": "AB889X", + "68755": "AB889X", + "68756": "AB889X", + "68757": "AB891X", + "68758": "AB889X", + "68759": "AB889X", + "68760": "AB889X", + "68761": "AB889X", + "68763": "AB889X", + "68764": "AB889X", + "68765": "AB889X", + "68766": "AB889X", + "68767": "AB889X", + "68768": "AB889X", + "68769": "AB889X", + "68770": "AB891X", + "68771": "AB889X", + "68773": "AB889X", + "68774": "AB889X", + "68776": "AB891X", + "68777": "AB889X", + "68778": "AB889X", + "68779": "AB889X", + "68780": "AB889X", + "68781": "AB889X", + "68783": "AB889X", + "68784": "AB891X", + "68785": "AB889X", + "68786": "AB889X", + "68787": "AB891X", + "68788": "AB889X", + "68789": "AB889X", + "68790": "AB889X", + "68791": "AB889X", + "68792": "AB889X", + "68801": "AB889X", + "68802": "AB889X", + "68803": "AB889X", + "68810": "AB889X", + "68812": "AB889X", + "68813": "AB889X", + "68814": "AB889X", + "68815": "AB889X", + "68816": "AB889X", + "68817": "AB889X", + "68818": "AB889X", + "68820": "AB889X", + "68821": "AB889X", + "68822": "AB889X", + "68823": "AB889X", + "68824": "AB889X", + "68825": "AB889X", + "68826": "AB889X", + "68827": "AB889X", + "68828": "AB889X", + "68831": "AB889X", + "68832": "AB889X", + "68833": "AB889X", + "68834": "AB889X", + "68835": "AB889X", + "68836": "AB889X", + "68837": "AB889X", + "68838": "AB889X", + "68840": "AB889X", + "68841": "AB889X", + "68842": "AB889X", + "68843": "AB889X", + "68844": "AB889X", + "68845": "AB889X", + "68846": "AB889X", + "68847": "AB889X", + "68848": "AB889X", + "68849": "AB889X", + "68850": "AB889X", + "68852": "AB889X", + "68853": "AB889X", + "68854": "AB889X", + "68855": "AB889X", + "68856": "AB889X", + "68858": "AB889X", + "68859": "AB889X", + "68860": "AB889X", + "68861": "AB889X", + "68862": "AB889X", + "68863": "AB889X", + "68864": "AB889X", + "68865": "AB889X", + "68866": "AB889X", + "68869": "AB889X", + "68870": "AB889X", + "68871": "AB889X", + "68872": "AB889X", + "68873": "AB889X", + "68874": "AB889X", + "68875": "AB889X", + "68876": "AB889X", + "68878": "AB889X", + "68879": "AB889X", + "68881": "AB889X", + "68882": "AB889X", + "68883": "AB889X", + "68901": "AB889X", + "68902": "AB889X", + "68920": "AB889X", + "68922": "AB889X", + "68923": "AB889X", + "68924": "AB889X", + "68925": "AB889X", + "68926": "AB889X", + "68927": "AB889X", + "68928": "AB889X", + "68929": "AB889X", + "68930": "AB889X", + "68932": "AB889X", + "68933": "AB889X", + "68934": "AB889X", + "68935": "AB889X", + "68936": "AB889X", + "68937": "AB889X", + "68938": "AB889X", + "68939": "AB889X", + "68940": "AB889X", + "68941": "AB889X", + "68942": "AB889X", + "68943": "AB889X", + "68944": "AB889X", + "68945": "AB889X", + "68946": "AB889X", + "68947": "AB889X", + "68948": "AB889X", + "68949": "AB889X", + "68950": "AB889X", + "68952": "AB889X", + "68954": "AB889X", + "68955": "AB889X", + "68956": "AB889X", + "68957": "AB889X", + "68958": "AB889X", + "68959": "AB889X", + "68960": "AB889X", + "68961": "AB889X", + "68964": "AB889X", + "68966": "AB889X", + "68967": "AB889X", + "68969": "AB889X", + "68970": "AB889X", + "68971": "AB889X", + "68972": "AB889X", + "68973": "AB889X", + "68974": "AB889X", + "68975": "AB889X", + "68976": "AB889X", + "68977": "AB889X", + "68978": "AB889X", + "68979": "AB889X", + "68980": "AB889X", + "68981": "AB889X", + "68982": "AB889X", + "69001": "AB889X", + "69020": "AB889X", + "69021": "AB889X", + "69022": "AB889X", + "69023": "AB889X", + "69024": "AB889X", + "69025": "AB889X", + "69026": "AB889X", + "69027": "AB889X", + "69028": "AB889X", + "69029": "AB889X", + "69030": "AB889X", + "69032": "AB889X", + "69033": "AB889X", + "69034": "AB889X", + "69036": "AB889X", + "69037": "AB889X", + "69038": "AB889X", + "69039": "AB889X", + "69040": "AB889X", + "69041": "AB889X", + "69042": "AB889X", + "69043": "AB889X", + "69044": "AB889X", + "69045": "AB889X", + "69046": "AB889X", + "69101": "AB889X", + "69103": "AB889X", + "69120": "AB889X", + "69121": "AB889X", + "69122": "AB889X", + "69123": "AB889X", + "69125": "AB889X", + "69127": "AB889X", + "69128": "AB889X", + "69129": "AB889X", + "69130": "AB889X", + "69131": "AB887X", + "69132": "AB889X", + "69133": "AB887X", + "69134": "AB889X", + "69135": "AB889X", + "69138": "AB889X", + "69140": "AB889X", + "69141": "AB887X", + "69142": "AB889X", + "69143": "AB889X", + "69144": "AB889X", + "69145": "AB887X", + "69146": "AB889X", + "69147": "AB889X", + "69148": "AB889X", + "69149": "AB887X", + "69150": "AB889X", + "69151": "AB889X", + "69152": "AB889X", + "69153": "AB889X", + "69154": "AB889X", + "69155": "AB889X", + "69156": "AB887X", + "69157": "AB889X", + "69160": "AB889X", + "69161": "AB889X", + "69162": "AB887X", + "69163": "AB889X", + "69165": "AB889X", + "69166": "AB889X", + "69167": "AB889X", + "69168": "AB889X", + "69169": "AB889X", + "69170": "AB889X", + "69171": "AB889X", + "69190": "AB889X", + "69201": "AB889X", + "69210": "AB889X", + "69211": "AB889X", + "69212": "AB889X", + "69214": "AB889X", + "69216": "AB889X", + "69217": "AB889X", + "69218": "AB889X", + "69219": "AB889X", + "69220": "AB889X", + "69221": "AB889X", + "69301": "AB889X", + "69331": "AB889X", + "69333": "AB889X", + "69334": "AB889X", + "69335": "AB889X", + "69336": "AB889X", + "69337": "AB887X", + "69339": "AB887X", + "69340": "AB889X", + "69341": "AB889X", + "69343": "AB887X", + "69345": "AB889X", + "69346": "AB887X", + "69347": "AB887X", + "69348": "AB887X", + "69350": "AB889X", + "69351": "AB889X", + "69352": "AB889X", + "69353": "AB889X", + "69354": "AB887X", + "69355": "AB889X", + "69356": "AB889X", + "69357": "AB889X", + "69358": "AB889X", + "69360": "AB887X", + "69361": "AB887X", + "69363": "AB889X", + "69365": "AB889X", + "69366": "AB889X", + "69367": "AB887X", + "69999": "AB889X", + "70001": "AB889X", + "70002": "AB889X", + "70003": "AB889X", + "70004": "AB889X", + "70005": "AB889X", + "70006": "AB889X", + "70009": "AB889X", + "70010": "AB889X", + "70011": "AB889X", + "70030": "AB889X", + "70031": "AB889X", + "70032": "AB889X", + "70033": "AB889X", + "70036": "AB889X", + "70037": "AB889X", + "70038": "AB889X", + "70039": "AB889X", + "70040": "AB889X", + "70041": "AB889X", + "70043": "AB889X", + "70044": "AB889X", + "70047": "AB889X", + "70049": "AB889X", + "70050": "AB889X", + "70051": "AB889X", + "70052": "AB889X", + "70053": "AB889X", + "70054": "AB889X", + "70055": "AB889X", + "70056": "AB889X", + "70057": "AB889X", + "70058": "AB889X", + "70059": "AB889X", + "70060": "AB889X", + "70062": "AB889X", + "70063": "AB889X", + "70064": "AB889X", + "70065": "AB889X", + "70067": "AB889X", + "70068": "AB889X", + "70069": "AB889X", + "70070": "AB889X", + "70071": "AB889X", + "70072": "AB889X", + "70073": "AB889X", + "70075": "AB889X", + "70076": "AB889X", + "70078": "AB889X", + "70079": "AB889X", + "70080": "AB889X", + "70081": "AB889X", + "70082": "AB889X", + "70083": "AB889X", + "70084": "AB889X", + "70085": "AB889X", + "70086": "AB889X", + "70087": "AB889X", + "70090": "AB889X", + "70091": "AB889X", + "70092": "AB889X", + "70093": "AB889X", + "70094": "AB889X", + "70096": "AB889X", + "70097": "AB889X", + "70112": "AB889X", + "70113": "AB889X", + "70114": "AB889X", + "70115": "AB889X", + "70116": "AB889X", + "70117": "AB889X", + "70118": "AB889X", + "70119": "AB889X", + "70121": "AB889X", + "70122": "AB889X", + "70123": "AB889X", + "70124": "AB889X", + "70125": "AB889X", + "70126": "AB889X", + "70127": "AB889X", + "70128": "AB889X", + "70129": "AB889X", + "70130": "AB889X", + "70131": "AB889X", + "70139": "AB889X", + "70140": "AB889X", + "70141": "AB889X", + "70142": "AB889X", + "70143": "AB889X", + "70145": "AB889X", + "70146": "AB889X", + "70148": "AB889X", + "70149": "AB889X", + "70150": "AB889X", + "70151": "AB889X", + "70152": "AB889X", + "70153": "AB889X", + "70154": "AB889X", + "70156": "AB889X", + "70157": "AB889X", + "70158": "AB889X", + "70159": "AB889X", + "70160": "AB889X", + "70161": "AB889X", + "70162": "AB889X", + "70163": "AB889X", + "70164": "AB889X", + "70165": "AB889X", + "70166": "AB889X", + "70167": "AB889X", + "70170": "AB889X", + "70172": "AB889X", + "70174": "AB889X", + "70175": "AB889X", + "70176": "AB889X", + "70177": "AB889X", + "70178": "AB889X", + "70179": "AB889X", + "70181": "AB889X", + "70182": "AB889X", + "70183": "AB889X", + "70184": "AB889X", + "70185": "AB889X", + "70186": "AB889X", + "70187": "AB889X", + "70189": "AB889X", + "70190": "AB889X", + "70195": "AB889X", + "70301": "AB889X", + "70302": "AB889X", + "70310": "AB889X", + "70339": "AB889X", + "70340": "AB889X", + "70341": "AB889X", + "70342": "AB889X", + "70343": "AB889X", + "70344": "AB889X", + "70345": "AB889X", + "70346": "AB889X", + "70352": "AB889X", + "70353": "AB889X", + "70354": "AB889X", + "70355": "AB889X", + "70356": "AB889X", + "70357": "AB889X", + "70358": "AB889X", + "70359": "AB889X", + "70360": "AB889X", + "70361": "AB889X", + "70363": "AB889X", + "70364": "AB889X", + "70371": "AB889X", + "70372": "AB889X", + "70373": "AB889X", + "70374": "AB889X", + "70375": "AB889X", + "70377": "AB889X", + "70380": "AB889X", + "70381": "AB889X", + "70390": "AB889X", + "70391": "AB889X", + "70392": "AB889X", + "70393": "AB889X", + "70394": "AB889X", + "70395": "AB889X", + "70397": "AB889X", + "70401": "AB889X", + "70402": "AB889X", + "70403": "AB889X", + "70404": "AB889X", + "70420": "AB889X", + "70421": "AB889X", + "70422": "AB889X", + "70426": "AB889X", + "70427": "AB889X", + "70429": "AB889X", + "70431": "AB889X", + "70433": "AB889X", + "70434": "AB889X", + "70435": "AB889X", + "70436": "AB889X", + "70437": "AB889X", + "70438": "AB889X", + "70441": "AB889X", + "70442": "AB889X", + "70443": "AB889X", + "70444": "AB889X", + "70445": "AB889X", + "70446": "AB889X", + "70447": "AB889X", + "70448": "AB889X", + "70449": "AB889X", + "70450": "AB889X", + "70451": "AB889X", + "70452": "AB889X", + "70453": "AB889X", + "70454": "AB889X", + "70455": "AB889X", + "70456": "AB889X", + "70457": "AB889X", + "70458": "AB889X", + "70459": "AB889X", + "70460": "AB889X", + "70461": "AB889X", + "70462": "AB889X", + "70463": "AB889X", + "70464": "AB889X", + "70465": "AB889X", + "70466": "AB889X", + "70467": "AB889X", + "70469": "AB889X", + "70470": "AB889X", + "70471": "AB889X", + "70501": "AB887X", + "70502": "AB887X", + "70503": "AB887X", + "70504": "AB887X", + "70505": "AB887X", + "70506": "AB887X", + "70507": "AB887X", + "70508": "AB887X", + "70509": "AB887X", + "70510": "AB887X", + "70511": "AB887X", + "70512": "AB887X", + "70513": "AB887X", + "70514": "AB887X", + "70515": "AB887X", + "70516": "AB887X", + "70517": "AB887X", + "70518": "AB887X", + "70519": "AB887X", + "70520": "AB887X", + "70521": "AB887X", + "70522": "AB887X", + "70523": "AB887X", + "70524": "AB887X", + "70525": "AB887X", + "70526": "AB887X", + "70527": "AB887X", + "70528": "AB887X", + "70529": "AB887X", + "70531": "AB887X", + "70532": "AB887X", + "70533": "AB887X", + "70534": "AB887X", + "70535": "AB887X", + "70537": "AB887X", + "70538": "AB887X", + "70540": "AB887X", + "70541": "AB887X", + "70542": "AB887X", + "70543": "AB887X", + "70544": "AB887X", + "70546": "AB887X", + "70548": "AB887X", + "70549": "AB887X", + "70550": "AB887X", + "70551": "AB887X", + "70552": "AB887X", + "70554": "AB887X", + "70555": "AB887X", + "70556": "AB887X", + "70558": "AB887X", + "70559": "AB887X", + "70560": "AB887X", + "70562": "AB887X", + "70563": "AB887X", + "70569": "AB887X", + "70570": "AB887X", + "70571": "AB887X", + "70575": "AB887X", + "70576": "AB887X", + "70577": "AB887X", + "70578": "AB887X", + "70580": "AB887X", + "70581": "AB887X", + "70582": "AB887X", + "70583": "AB887X", + "70584": "AB887X", + "70585": "AB887X", + "70586": "AB887X", + "70589": "AB887X", + "70591": "AB887X", + "70592": "AB887X", + "70593": "AB887X", + "70595": "AB887X", + "70596": "AB887X", + "70598": "AB887X", + "70601": "AB887X", + "70602": "AB887X", + "70605": "AB887X", + "70606": "AB887X", + "70607": "AB887X", + "70609": "AB887X", + "70611": "AB887X", + "70612": "AB887X", + "70615": "AB887X", + "70616": "AB887X", + "70629": "AB887X", + "70630": "AB887X", + "70631": "AB887X", + "70632": "AB887X", + "70633": "AB887X", + "70634": "AB887X", + "70637": "AB887X", + "70638": "AB887X", + "70639": "AB887X", + "70640": "AB887X", + "70643": "AB887X", + "70644": "AB887X", + "70645": "AB887X", + "70646": "AB887X", + "70647": "AB887X", + "70648": "AB887X", + "70650": "AB887X", + "70651": "AB887X", + "70652": "AB887X", + "70653": "AB887X", + "70654": "AB887X", + "70655": "AB887X", + "70656": "AB887X", + "70657": "AB887X", + "70658": "AB887X", + "70659": "AB887X", + "70660": "AB887X", + "70661": "AB887X", + "70662": "AB887X", + "70663": "AB887X", + "70664": "AB887X", + "70665": "AB887X", + "70668": "AB887X", + "70669": "AB887X", + "70704": "AB889X", + "70706": "AB889X", + "70707": "AB889X", + "70710": "AB889X", + "70711": "AB889X", + "70712": "AB889X", + "70714": "AB889X", + "70715": "AB889X", + "70718": "AB889X", + "70719": "AB889X", + "70721": "AB889X", + "70722": "AB889X", + "70723": "AB889X", + "70725": "AB889X", + "70726": "AB889X", + "70727": "AB887X", + "70728": "AB889X", + "70729": "AB889X", + "70730": "AB889X", + "70732": "AB889X", + "70733": "AB889X", + "70734": "AB889X", + "70736": "AB889X", + "70737": "AB889X", + "70738": "AB889X", + "70739": "AB889X", + "70740": "AB889X", + "70743": "AB889X", + "70744": "AB889X", + "70747": "AB889X", + "70748": "AB889X", + "70749": "AB889X", + "70750": "AB887X", + "70752": "AB889X", + "70753": "AB889X", + "70754": "AB889X", + "70755": "AB889X", + "70756": "AB889X", + "70757": "AB889X", + "70759": "AB889X", + "70760": "AB889X", + "70761": "AB889X", + "70762": "AB889X", + "70763": "AB889X", + "70764": "AB889X", + "70765": "AB889X", + "70767": "AB889X", + "70769": "AB889X", + "70770": "AB889X", + "70772": "AB889X", + "70773": "AB889X", + "70774": "AB889X", + "70775": "AB889X", + "70776": "AB889X", + "70777": "AB889X", + "70778": "AB889X", + "70780": "AB889X", + "70782": "AB889X", + "70783": "AB889X", + "70784": "AB889X", + "70785": "AB889X", + "70786": "AB889X", + "70787": "AB889X", + "70788": "AB889X", + "70789": "AB889X", + "70791": "AB889X", + "70792": "AB889X", + "70801": "AB887X", + "70802": "AB887X", + "70803": "AB889X", + "70804": "AB889X", + "70805": "AB889X", + "70806": "AB889X", + "70807": "AB889X", + "70808": "AB889X", + "70809": "AB889X", + "70810": "AB889X", + "70811": "AB889X", + "70812": "AB889X", + "70813": "AB889X", + "70814": "AB889X", + "70815": "AB889X", + "70816": "AB889X", + "70817": "AB889X", + "70818": "AB889X", + "70819": "AB889X", + "70820": "AB889X", + "70821": "AB889X", + "70822": "AB889X", + "70823": "AB889X", + "70825": "AB889X", + "70826": "AB889X", + "70827": "AB889X", + "70831": "AB889X", + "70833": "AB889X", + "70835": "AB889X", + "70836": "AB889X", + "70837": "AB889X", + "70873": "AB889X", + "70874": "AB889X", + "70879": "AB889X", + "70883": "AB889X", + "70884": "AB889X", + "70891": "AB889X", + "70892": "AB889X", + "70893": "AB889X", + "70894": "AB889X", + "70895": "AB889X", + "70896": "AB889X", + "70898": "AB889X", + "71001": "AB887X", + "71002": "AB888X", + "71003": "AB888X", + "71004": "AB888X", + "71006": "AB888X", + "71007": "AB888X", + "71008": "AB887X", + "71009": "AB888X", + "71016": "AB887X", + "71018": "AB888X", + "71019": "AB888X", + "71021": "AB888X", + "71023": "AB888X", + "71024": "AB888X", + "71027": "AB888X", + "71028": "AB887X", + "71029": "AB888X", + "71030": "AB888X", + "71031": "AB887X", + "71032": "AB888X", + "71033": "AB888X", + "71034": "AB888X", + "71037": "AB888X", + "71038": "AB888X", + "71039": "AB888X", + "71040": "AB888X", + "71043": "AB888X", + "71044": "AB888X", + "71045": "AB887X", + "71046": "AB888X", + "71047": "AB888X", + "71048": "AB888X", + "71049": "AB888X", + "71050": "AB888X", + "71051": "AB888X", + "71052": "AB888X", + "71055": "AB888X", + "71058": "AB888X", + "71060": "AB888X", + "71061": "AB888X", + "71063": "AB888X", + "71064": "AB888X", + "71065": "AB888X", + "71066": "AB888X", + "71067": "AB888X", + "71068": "AB888X", + "71069": "AB888X", + "71070": "AB887X", + "71071": "AB888X", + "71072": "AB888X", + "71073": "AB888X", + "71075": "AB888X", + "71078": "AB888X", + "71079": "AB888X", + "71080": "AB887X", + "71082": "AB888X", + "71101": "AB888X", + "71102": "AB888X", + "71103": "AB888X", + "71104": "AB888X", + "71105": "AB888X", + "71106": "AB888X", + "71107": "AB888X", + "71108": "AB888X", + "71109": "AB888X", + "71110": "AB888X", + "71111": "AB888X", + "71112": "AB888X", + "71113": "AB888X", + "71115": "AB888X", + "71118": "AB888X", + "71119": "AB888X", + "71120": "AB888X", + "71129": "AB888X", + "71130": "AB888X", + "71133": "AB888X", + "71134": "AB888X", + "71135": "AB888X", + "71136": "AB888X", + "71137": "AB888X", + "71138": "AB888X", + "71148": "AB888X", + "71149": "AB888X", + "71150": "AB888X", + "71151": "AB888X", + "71152": "AB888X", + "71153": "AB888X", + "71154": "AB888X", + "71156": "AB888X", + "71161": "AB888X", + "71162": "AB888X", + "71163": "AB888X", + "71164": "AB888X", + "71165": "AB888X", + "71166": "AB888X", + "71171": "AB888X", + "71172": "AB888X", + "71201": "AB887X", + "71202": "AB887X", + "71203": "AB887X", + "71207": "AB887X", + "71208": "AB887X", + "71209": "AB887X", + "71210": "AB887X", + "71211": "AB887X", + "71212": "AB887X", + "71213": "AB887X", + "71217": "AB887X", + "71218": "AB887X", + "71219": "AB887X", + "71220": "AB887X", + "71221": "AB887X", + "71222": "AB887X", + "71223": "AB887X", + "71225": "AB887X", + "71226": "AB887X", + "71227": "AB887X", + "71229": "AB887X", + "71230": "AB887X", + "71232": "AB887X", + "71233": "AB887X", + "71234": "AB887X", + "71235": "AB887X", + "71237": "AB887X", + "71238": "AB887X", + "71240": "AB887X", + "71241": "AB887X", + "71242": "AB887X", + "71243": "AB887X", + "71245": "AB887X", + "71247": "AB887X", + "71249": "AB887X", + "71250": "AB887X", + "71251": "AB887X", + "71253": "AB887X", + "71254": "AB887X", + "71256": "AB887X", + "71259": "AB887X", + "71260": "AB887X", + "71261": "AB887X", + "71263": "AB887X", + "71264": "AB887X", + "71266": "AB887X", + "71268": "AB887X", + "71269": "AB887X", + "71270": "AB887X", + "71272": "AB887X", + "71273": "AB887X", + "71275": "AB887X", + "71276": "AB887X", + "71277": "AB887X", + "71279": "AB887X", + "71280": "AB887X", + "71281": "AB887X", + "71282": "AB887X", + "71284": "AB887X", + "71286": "AB887X", + "71291": "AB887X", + "71292": "AB887X", + "71294": "AB887X", + "71295": "AB887X", + "71301": "AB887X", + "71302": "AB887X", + "71303": "AB887X", + "71306": "AB887X", + "71307": "AB887X", + "71309": "AB887X", + "71315": "AB887X", + "71316": "AB887X", + "71320": "AB887X", + "71322": "AB887X", + "71323": "AB887X", + "71324": "AB887X", + "71325": "AB887X", + "71326": "AB887X", + "71327": "AB887X", + "71328": "AB887X", + "71329": "AB887X", + "71330": "AB887X", + "71331": "AB887X", + "71333": "AB887X", + "71334": "AB887X", + "71336": "AB887X", + "71339": "AB887X", + "71340": "AB887X", + "71341": "AB887X", + "71342": "AB887X", + "71343": "AB887X", + "71345": "AB887X", + "71346": "AB887X", + "71347": "AB887X", + "71348": "AB887X", + "71350": "AB887X", + "71351": "AB887X", + "71353": "AB887X", + "71354": "AB887X", + "71355": "AB887X", + "71356": "AB887X", + "71357": "AB887X", + "71358": "AB887X", + "71359": "AB887X", + "71360": "AB887X", + "71361": "AB887X", + "71362": "AB887X", + "71363": "AB887X", + "71365": "AB887X", + "71366": "AB887X", + "71367": "AB887X", + "71368": "AB887X", + "71369": "AB887X", + "71371": "AB887X", + "71373": "AB887X", + "71375": "AB887X", + "71377": "AB887X", + "71378": "AB887X", + "71401": "AB887X", + "71403": "AB887X", + "71404": "AB887X", + "71405": "AB887X", + "71406": "AB888X", + "71407": "AB887X", + "71409": "AB887X", + "71410": "AB887X", + "71411": "AB888X", + "71412": "AB888X", + "71414": "AB888X", + "71415": "AB888X", + "71416": "AB888X", + "71417": "AB887X", + "71418": "AB888X", + "71419": "AB888X", + "71422": "AB887X", + "71423": "AB887X", + "71424": "AB887X", + "71425": "AB887X", + "71426": "AB888X", + "71427": "AB887X", + "71428": "AB888X", + "71429": "AB888X", + "71430": "AB887X", + "71431": "AB887X", + "71432": "AB887X", + "71433": "AB887X", + "71434": "AB888X", + "71435": "AB888X", + "71438": "AB887X", + "71439": "AB888X", + "71440": "AB887X", + "71441": "AB888X", + "71443": "AB887X", + "71444": "AB887X", + "71446": "AB887X", + "71447": "AB888X", + "71448": "AB887X", + "71449": "AB888X", + "71450": "AB888X", + "71452": "AB888X", + "71454": "AB887X", + "71455": "AB888X", + "71456": "AB888X", + "71457": "AB888X", + "71458": "AB888X", + "71459": "AB887X", + "71460": "AB888X", + "71461": "AB887X", + "71462": "AB888X", + "71463": "AB887X", + "71465": "AB887X", + "71466": "AB887X", + "71467": "AB887X", + "71468": "AB888X", + "71469": "AB888X", + "71471": "AB888X", + "71472": "AB887X", + "71473": "AB887X", + "71474": "AB887X", + "71475": "AB887X", + "71477": "AB887X", + "71479": "AB887X", + "71480": "AB887X", + "71483": "AB887X", + "71485": "AB887X", + "71486": "AB888X", + "71496": "AB887X", + "71497": "AB890X", + "71601": "AB887X", + "71602": "AB887X", + "71603": "AB887X", + "71611": "AB887X", + "71612": "AB887X", + "71613": "AB887X", + "71630": "AB887X", + "71631": "AB887X", + "71635": "AB887X", + "71638": "AB889X", + "71639": "AB887X", + "71640": "AB889X", + "71642": "AB887X", + "71643": "AB887X", + "71644": "AB887X", + "71646": "AB887X", + "71647": "AB887X", + "71651": "AB887X", + "71652": "AB887X", + "71653": "AB889X", + "71654": "AB887X", + "71655": "AB887X", + "71656": "AB887X", + "71657": "AB887X", + "71658": "AB887X", + "71659": "AB887X", + "71660": "AB887X", + "71661": "AB887X", + "71662": "AB887X", + "71663": "AB887X", + "71665": "AB887X", + "71666": "AB887X", + "71667": "AB887X", + "71670": "AB887X", + "71671": "AB887X", + "71674": "AB887X", + "71675": "AB887X", + "71676": "AB887X", + "71677": "AB887X", + "71678": "AB887X", + "71701": "AB887X", + "71711": "AB887X", + "71716": "AB887X", + "71720": "AB887X", + "71721": "AB887X", + "71722": "AB888X", + "71724": "AB887X", + "71725": "AB887X", + "71726": "AB887X", + "71728": "AB887X", + "71730": "AB887X", + "71731": "AB887X", + "71740": "AB888X", + "71742": "AB887X", + "71743": "AB887X", + "71744": "AB887X", + "71745": "AB887X", + "71747": "AB887X", + "71748": "AB887X", + "71749": "AB887X", + "71750": "AB887X", + "71751": "AB887X", + "71752": "AB888X", + "71753": "AB888X", + "71754": "AB888X", + "71758": "AB887X", + "71759": "AB887X", + "71762": "AB887X", + "71763": "AB887X", + "71764": "AB887X", + "71765": "AB887X", + "71766": "AB887X", + "71768": "AB887X", + "71770": "AB888X", + "71772": "AB887X", + "71801": "AB888X", + "71802": "AB888X", + "71820": "AB888X", + "71822": "AB888X", + "71823": "AB888X", + "71825": "AB888X", + "71826": "AB888X", + "71827": "AB888X", + "71828": "AB888X", + "71831": "AB888X", + "71832": "AB888X", + "71833": "AB888X", + "71834": "AB888X", + "71835": "AB888X", + "71836": "AB888X", + "71837": "AB888X", + "71838": "AB888X", + "71839": "AB888X", + "71840": "AB888X", + "71841": "AB888X", + "71842": "AB888X", + "71844": "AB888X", + "71845": "AB888X", + "71846": "AB888X", + "71847": "AB888X", + "71851": "AB888X", + "71852": "AB888X", + "71853": "AB888X", + "71854": "AB888X", + "71855": "AB888X", + "71857": "AB888X", + "71858": "AB888X", + "71859": "AB888X", + "71860": "AB888X", + "71861": "AB888X", + "71862": "AB888X", + "71864": "AB888X", + "71865": "AB888X", + "71866": "AB888X", + "71901": "AB887X", + "71902": "AB887X", + "71903": "AB887X", + "71909": "AB887X", + "71910": "AB887X", + "71913": "AB887X", + "71914": "AB887X", + "71920": "AB887X", + "71921": "AB887X", + "71922": "AB887X", + "71923": "AB887X", + "71928": "AB887X", + "71929": "AB887X", + "71932": "AB890X", + "71933": "AB887X", + "71935": "AB887X", + "71937": "AB890X", + "71940": "AB887X", + "71941": "AB887X", + "71942": "AB887X", + "71943": "AB887X", + "71944": "AB890X", + "71945": "AB890X", + "71946": "AB887X", + "71949": "AB887X", + "71950": "AB887X", + "71951": "AB887X", + "71952": "AB887X", + "71953": "AB890X", + "71956": "AB887X", + "71957": "AB887X", + "71958": "AB887X", + "71959": "AB887X", + "71960": "AB887X", + "71961": "AB890X", + "71962": "AB887X", + "71964": "AB887X", + "71965": "AB887X", + "71966": "AB887X", + "71968": "AB887X", + "71969": "AB887X", + "71970": "AB887X", + "71971": "AB888X", + "71972": "AB890X", + "71973": "AB890X", + "71998": "AB887X", + "71999": "AB887X", + "72001": "AB887X", + "72002": "AB887X", + "72003": "AB887X", + "72004": "AB887X", + "72005": "AB887X", + "72006": "AB889X", + "72007": "AB887X", + "72010": "AB887X", + "72011": "AB887X", + "72012": "AB887X", + "72013": "AB887X", + "72014": "AB887X", + "72015": "AB887X", + "72016": "AB887X", + "72017": "AB889X", + "72018": "AB887X", + "72019": "AB887X", + "72020": "AB887X", + "72021": "AB889X", + "72022": "AB887X", + "72023": "AB887X", + "72024": "AB887X", + "72025": "AB887X", + "72026": "AB887X", + "72027": "AB887X", + "72028": "AB887X", + "72029": "AB889X", + "72030": "AB887X", + "72031": "AB887X", + "72032": "AB887X", + "72033": "AB887X", + "72034": "AB887X", + "72035": "AB887X", + "72036": "AB889X", + "72037": "AB887X", + "72038": "AB887X", + "72039": "AB887X", + "72040": "AB889X", + "72041": "AB889X", + "72042": "AB887X", + "72043": "AB888X", + "72044": "AB887X", + "72045": "AB887X", + "72046": "AB887X", + "72047": "AB887X", + "72048": "AB887X", + "72051": "AB887X", + "72052": "AB887X", + "72053": "AB887X", + "72055": "AB887X", + "72057": "AB887X", + "72058": "AB887X", + "72059": "AB889X", + "72060": "AB889X", + "72061": "AB887X", + "72063": "AB887X", + "72064": "AB889X", + "72065": "AB887X", + "72066": "AB889X", + "72067": "AB887X", + "72068": "AB887X", + "72069": "AB889X", + "72070": "AB887X", + "72072": "AB887X", + "72073": "AB887X", + "72074": "AB889X", + "72075": "AB888X", + "72076": "AB887X", + "72078": "AB887X", + "72079": "AB887X", + "72080": "AB887X", + "72081": "AB887X", + "72082": "AB887X", + "72083": "AB887X", + "72084": "AB887X", + "72085": "AB887X", + "72086": "AB887X", + "72087": "AB887X", + "72088": "AB887X", + "72089": "AB887X", + "72099": "AB887X", + "72101": "AB888X", + "72102": "AB887X", + "72103": "AB887X", + "72104": "AB887X", + "72105": "AB887X", + "72106": "AB887X", + "72107": "AB887X", + "72108": "AB889X", + "72110": "AB887X", + "72111": "AB887X", + "72112": "AB887X", + "72113": "AB887X", + "72114": "AB887X", + "72115": "AB887X", + "72116": "AB887X", + "72117": "AB887X", + "72118": "AB887X", + "72119": "AB887X", + "72120": "AB887X", + "72121": "AB887X", + "72122": "AB887X", + "72123": "AB889X", + "72124": "AB887X", + "72125": "AB887X", + "72126": "AB887X", + "72127": "AB887X", + "72128": "AB887X", + "72129": "AB887X", + "72130": "AB887X", + "72131": "AB887X", + "72132": "AB887X", + "72133": "AB887X", + "72134": "AB887X", + "72135": "AB887X", + "72136": "AB887X", + "72137": "AB887X", + "72139": "AB887X", + "72140": "AB887X", + "72141": "AB887X", + "72142": "AB887X", + "72143": "AB887X", + "72145": "AB887X", + "72149": "AB887X", + "72150": "AB887X", + "72152": "AB887X", + "72153": "AB887X", + "72156": "AB887X", + "72157": "AB887X", + "72158": "AB887X", + "72160": "AB887X", + "72164": "AB887X", + "72165": "AB887X", + "72166": "AB887X", + "72167": "AB887X", + "72168": "AB887X", + "72169": "AB888X", + "72170": "AB887X", + "72173": "AB887X", + "72175": "AB887X", + "72176": "AB887X", + "72178": "AB887X", + "72179": "AB887X", + "72180": "AB887X", + "72181": "AB887X", + "72182": "AB887X", + "72183": "AB887X", + "72189": "AB889X", + "72190": "AB887X", + "72198": "AB887X", + "72199": "AB887X", + "72201": "AB887X", + "72202": "AB887X", + "72203": "AB887X", + "72204": "AB887X", + "72205": "AB887X", + "72206": "AB887X", + "72207": "AB887X", + "72209": "AB887X", + "72210": "AB887X", + "72211": "AB887X", + "72212": "AB887X", + "72214": "AB887X", + "72215": "AB887X", + "72216": "AB887X", + "72217": "AB887X", + "72219": "AB887X", + "72221": "AB887X", + "72222": "AB887X", + "72223": "AB887X", + "72225": "AB887X", + "72227": "AB887X", + "72231": "AB887X", + "72260": "AB887X", + "72295": "AB887X", + "72301": "AB889X", + "72303": "AB887X", + "72310": "AB889X", + "72311": "AB889X", + "72312": "AB889X", + "72313": "AB889X", + "72315": "AB889X", + "72316": "AB889X", + "72319": "AB887X", + "72320": "AB887X", + "72321": "AB889X", + "72322": "AB889X", + "72324": "AB888X", + "72325": "AB887X", + "72326": "AB889X", + "72327": "AB887X", + "72328": "AB889X", + "72329": "AB889X", + "72330": "AB889X", + "72331": "AB887X", + "72332": "AB887X", + "72333": "AB889X", + "72335": "AB889X", + "72336": "AB889X", + "72338": "AB889X", + "72339": "AB887X", + "72340": "AB889X", + "72341": "AB889X", + "72342": "AB889X", + "72346": "AB887X", + "72347": "AB888X", + "72348": "AB889X", + "72350": "AB889X", + "72351": "AB889X", + "72352": "AB889X", + "72353": "AB889X", + "72354": "AB888X", + "72355": "AB889X", + "72358": "AB889X", + "72359": "AB889X", + "72360": "AB889X", + "72364": "AB889X", + "72365": "AB888X", + "72366": "AB889X", + "72367": "AB889X", + "72368": "AB889X", + "72369": "AB889X", + "72370": "AB889X", + "72372": "AB889X", + "72373": "AB887X", + "72374": "AB889X", + "72376": "AB889X", + "72377": "AB888X", + "72379": "AB887X", + "72383": "AB889X", + "72384": "AB887X", + "72386": "AB888X", + "72387": "AB888X", + "72389": "AB889X", + "72390": "AB889X", + "72391": "AB889X", + "72392": "AB889X", + "72394": "AB889X", + "72395": "AB889X", + "72396": "AB889X", + "72401": "AB888X", + "72402": "AB888X", + "72403": "AB888X", + "72404": "AB888X", + "72410": "AB888X", + "72411": "AB888X", + "72412": "AB888X", + "72413": "AB888X", + "72414": "AB888X", + "72415": "AB888X", + "72416": "AB888X", + "72417": "AB888X", + "72419": "AB888X", + "72421": "AB888X", + "72422": "AB888X", + "72424": "AB888X", + "72425": "AB888X", + "72426": "AB889X", + "72427": "AB888X", + "72428": "AB889X", + "72429": "AB888X", + "72430": "AB888X", + "72431": "AB887X", + "72432": "AB888X", + "72433": "AB888X", + "72434": "AB888X", + "72435": "AB888X", + "72436": "AB888X", + "72437": "AB888X", + "72438": "AB888X", + "72439": "AB888X", + "72440": "AB888X", + "72441": "AB888X", + "72442": "AB888X", + "72443": "AB888X", + "72444": "AB888X", + "72445": "AB888X", + "72447": "AB888X", + "72449": "AB888X", + "72450": "AB888X", + "72451": "AB888X", + "72453": "AB888X", + "72454": "AB888X", + "72455": "AB888X", + "72456": "AB888X", + "72457": "AB888X", + "72458": "AB888X", + "72459": "AB888X", + "72460": "AB888X", + "72461": "AB888X", + "72462": "AB888X", + "72464": "AB888X", + "72465": "AB888X", + "72466": "AB888X", + "72467": "AB887X", + "72469": "AB888X", + "72470": "AB887X", + "72471": "AB888X", + "72472": "AB888X", + "72473": "AB888X", + "72474": "AB888X", + "72475": "AB888X", + "72476": "AB888X", + "72478": "AB888X", + "72479": "AB888X", + "72482": "AB888X", + "72501": "AB887X", + "72503": "AB887X", + "72512": "AB887X", + "72513": "AB888X", + "72515": "AB888X", + "72517": "AB888X", + "72519": "AB891X", + "72520": "AB888X", + "72521": "AB888X", + "72522": "AB887X", + "72523": "AB887X", + "72524": "AB887X", + "72525": "AB888X", + "72526": "AB887X", + "72527": "AB887X", + "72528": "AB887X", + "72529": "AB888X", + "72530": "AB887X", + "72531": "AB888X", + "72532": "AB888X", + "72533": "AB887X", + "72534": "AB887X", + "72536": "AB887X", + "72537": "AB891X", + "72538": "AB888X", + "72539": "AB888X", + "72540": "AB887X", + "72542": "AB888X", + "72543": "AB887X", + "72544": "AB891X", + "72545": "AB887X", + "72546": "AB887X", + "72550": "AB887X", + "72553": "AB887X", + "72554": "AB888X", + "72555": "AB887X", + "72556": "AB887X", + "72560": "AB887X", + "72561": "AB887X", + "72562": "AB887X", + "72564": "AB887X", + "72565": "AB888X", + "72566": "AB891X", + "72567": "AB887X", + "72568": "AB887X", + "72569": "AB888X", + "72571": "AB887X", + "72572": "AB888X", + "72573": "AB887X", + "72575": "AB887X", + "72576": "AB888X", + "72577": "AB888X", + "72578": "AB888X", + "72579": "AB887X", + "72581": "AB887X", + "72583": "AB888X", + "72584": "AB888X", + "72585": "AB887X", + "72587": "AB888X", + "72601": "AB891X", + "72602": "AB891X", + "72611": "AB891X", + "72613": "AB891X", + "72615": "AB891X", + "72616": "AB891X", + "72617": "AB891X", + "72619": "AB891X", + "72623": "AB891X", + "72624": "AB891X", + "72626": "AB891X", + "72628": "AB891X", + "72629": "AB887X", + "72630": "AB891X", + "72631": "AB891X", + "72632": "AB891X", + "72633": "AB891X", + "72634": "AB891X", + "72635": "AB891X", + "72636": "AB891X", + "72638": "AB891X", + "72639": "AB887X", + "72640": "AB891X", + "72641": "AB891X", + "72642": "AB891X", + "72644": "AB891X", + "72645": "AB887X", + "72648": "AB891X", + "72650": "AB891X", + "72651": "AB891X", + "72653": "AB891X", + "72654": "AB891X", + "72655": "AB891X", + "72657": "AB887X", + "72658": "AB891X", + "72659": "AB891X", + "72660": "AB891X", + "72661": "AB891X", + "72662": "AB891X", + "72663": "AB887X", + "72666": "AB891X", + "72668": "AB891X", + "72669": "AB891X", + "72670": "AB891X", + "72672": "AB891X", + "72675": "AB891X", + "72677": "AB891X", + "72679": "AB887X", + "72680": "AB887X", + "72682": "AB891X", + "72683": "AB891X", + "72685": "AB891X", + "72686": "AB891X", + "72687": "AB891X", + "72701": "AB890X", + "72702": "AB890X", + "72703": "AB890X", + "72704": "AB890X", + "72711": "AB890X", + "72712": "AB890X", + "72714": "AB890X", + "72715": "AB890X", + "72716": "AB890X", + "72717": "AB890X", + "72718": "AB890X", + "72719": "AB890X", + "72721": "AB890X", + "72722": "AB890X", + "72727": "AB890X", + "72728": "AB890X", + "72729": "AB890X", + "72730": "AB890X", + "72732": "AB890X", + "72733": "AB890X", + "72734": "AB890X", + "72735": "AB890X", + "72736": "AB890X", + "72737": "AB890X", + "72738": "AB890X", + "72739": "AB890X", + "72740": "AB890X", + "72741": "AB890X", + "72742": "AB890X", + "72744": "AB890X", + "72745": "AB890X", + "72747": "AB890X", + "72749": "AB890X", + "72751": "AB890X", + "72752": "AB890X", + "72753": "AB890X", + "72756": "AB890X", + "72757": "AB890X", + "72758": "AB890X", + "72760": "AB890X", + "72761": "AB890X", + "72762": "AB890X", + "72764": "AB890X", + "72765": "AB890X", + "72766": "AB890X", + "72768": "AB890X", + "72769": "AB890X", + "72770": "AB890X", + "72773": "AB890X", + "72774": "AB890X", + "72776": "AB890X", + "72801": "AB887X", + "72802": "AB887X", + "72811": "AB887X", + "72812": "AB887X", + "72820": "AB890X", + "72821": "AB887X", + "72823": "AB887X", + "72824": "AB887X", + "72826": "AB887X", + "72827": "AB887X", + "72828": "AB887X", + "72829": "AB887X", + "72830": "AB887X", + "72832": "AB887X", + "72833": "AB887X", + "72834": "AB887X", + "72835": "AB890X", + "72837": "AB887X", + "72838": "AB887X", + "72839": "AB887X", + "72840": "AB887X", + "72841": "AB887X", + "72842": "AB887X", + "72843": "AB887X", + "72845": "AB887X", + "72846": "AB887X", + "72847": "AB887X", + "72851": "AB890X", + "72852": "AB887X", + "72853": "AB887X", + "72854": "AB887X", + "72855": "AB890X", + "72856": "AB891X", + "72857": "AB887X", + "72858": "AB887X", + "72860": "AB887X", + "72863": "AB890X", + "72865": "AB890X", + "72901": "AB890X", + "72902": "AB890X", + "72903": "AB890X", + "72904": "AB890X", + "72905": "AB890X", + "72906": "AB890X", + "72908": "AB890X", + "72913": "AB890X", + "72914": "AB890X", + "72916": "AB890X", + "72917": "AB890X", + "72918": "AB890X", + "72919": "AB890X", + "72921": "AB890X", + "72923": "AB890X", + "72926": "AB890X", + "72927": "AB890X", + "72928": "AB890X", + "72930": "AB890X", + "72932": "AB890X", + "72933": "AB890X", + "72934": "AB890X", + "72935": "AB890X", + "72936": "AB890X", + "72937": "AB890X", + "72938": "AB890X", + "72940": "AB890X", + "72941": "AB890X", + "72943": "AB890X", + "72944": "AB890X", + "72945": "AB890X", + "72946": "AB890X", + "72947": "AB890X", + "72948": "AB890X", + "72949": "AB890X", + "72950": "AB890X", + "72951": "AB890X", + "72952": "AB890X", + "72955": "AB890X", + "72956": "AB890X", + "72957": "AB890X", + "72958": "AB890X", + "72959": "AB890X", + "73001": "AB890X", + "73002": "AB890X", + "73003": "AB890X", + "73004": "AB890X", + "73005": "AB890X", + "73006": "AB890X", + "73007": "AB890X", + "73008": "AB890X", + "73009": "AB890X", + "73010": "AB890X", + "73011": "AB890X", + "73012": "AB890X", + "73013": "AB890X", + "73014": "AB890X", + "73015": "AB890X", + "73016": "AB890X", + "73017": "AB890X", + "73018": "AB890X", + "73019": "AB890X", + "73020": "AB890X", + "73021": "AB890X", + "73022": "AB890X", + "73023": "AB890X", + "73024": "AB890X", + "73025": "AB890X", + "73026": "AB890X", + "73027": "AB890X", + "73028": "AB890X", + "73029": "AB890X", + "73030": "AB890X", + "73031": "AB890X", + "73032": "AB890X", + "73033": "AB890X", + "73034": "AB890X", + "73036": "AB890X", + "73038": "AB890X", + "73039": "AB890X", + "73040": "AB890X", + "73041": "AB890X", + "73042": "AB890X", + "73043": "AB890X", + "73044": "AB890X", + "73045": "AB890X", + "73047": "AB890X", + "73048": "AB890X", + "73049": "AB890X", + "73050": "AB890X", + "73051": "AB890X", + "73052": "AB890X", + "73053": "AB890X", + "73054": "AB890X", + "73055": "AB890X", + "73056": "AB890X", + "73057": "AB890X", + "73058": "AB890X", + "73059": "AB890X", + "73061": "AB890X", + "73062": "AB890X", + "73063": "AB890X", + "73064": "AB890X", + "73065": "AB890X", + "73066": "AB890X", + "73067": "AB890X", + "73068": "AB890X", + "73069": "AB890X", + "73070": "AB890X", + "73071": "AB890X", + "73072": "AB890X", + "73073": "AB890X", + "73074": "AB890X", + "73075": "AB890X", + "73077": "AB890X", + "73078": "AB890X", + "73079": "AB890X", + "73080": "AB890X", + "73081": "AB887X", + "73082": "AB890X", + "73083": "AB890X", + "73084": "AB890X", + "73085": "AB890X", + "73086": "AB890X", + "73089": "AB890X", + "73090": "AB890X", + "73092": "AB890X", + "73093": "AB890X", + "73094": "AB890X", + "73095": "AB890X", + "73096": "AB890X", + "73097": "AB890X", + "73098": "AB890X", + "73099": "AB890X", + "73101": "AB890X", + "73102": "AB890X", + "73103": "AB890X", + "73104": "AB890X", + "73105": "AB890X", + "73106": "AB890X", + "73107": "AB890X", + "73108": "AB890X", + "73109": "AB890X", + "73110": "AB890X", + "73111": "AB890X", + "73112": "AB890X", + "73113": "AB890X", + "73114": "AB890X", + "73115": "AB890X", + "73116": "AB890X", + "73117": "AB890X", + "73118": "AB890X", + "73119": "AB890X", + "73120": "AB890X", + "73121": "AB890X", + "73122": "AB890X", + "73123": "AB890X", + "73124": "AB890X", + "73125": "AB890X", + "73126": "AB890X", + "73127": "AB890X", + "73128": "AB890X", + "73129": "AB890X", + "73130": "AB890X", + "73131": "AB890X", + "73132": "AB890X", + "73134": "AB890X", + "73135": "AB890X", + "73136": "AB890X", + "73137": "AB890X", + "73139": "AB890X", + "73140": "AB890X", + "73141": "AB890X", + "73142": "AB890X", + "73143": "AB890X", + "73144": "AB890X", + "73145": "AB890X", + "73146": "AB890X", + "73147": "AB890X", + "73148": "AB890X", + "73149": "AB890X", + "73150": "AB890X", + "73151": "AB890X", + "73152": "AB890X", + "73153": "AB890X", + "73154": "AB890X", + "73155": "AB890X", + "73156": "AB890X", + "73157": "AB890X", + "73159": "AB890X", + "73160": "AB890X", + "73162": "AB890X", + "73163": "AB890X", + "73164": "AB890X", + "73165": "AB890X", + "73167": "AB890X", + "73169": "AB890X", + "73170": "AB890X", + "73172": "AB890X", + "73173": "AB890X", + "73178": "AB890X", + "73179": "AB890X", + "73184": "AB890X", + "73185": "AB890X", + "73189": "AB890X", + "73190": "AB890X", + "73193": "AB890X", + "73194": "AB890X", + "73195": "AB890X", + "73196": "AB890X", + "73197": "AB890X", + "73198": "AB890X", + "73199": "AB890X", + "73301": "AB890X", + "73344": "AB890X", + "73401": "AB887X", + "73402": "AB887X", + "73403": "AB887X", + "73425": "AB890X", + "73430": "AB887X", + "73432": "AB890X", + "73433": "AB890X", + "73434": "AB890X", + "73435": "AB887X", + "73436": "AB887X", + "73437": "AB887X", + "73438": "AB887X", + "73439": "AB887X", + "73440": "AB887X", + "73441": "AB887X", + "73442": "AB890X", + "73443": "AB887X", + "73444": "AB887X", + "73446": "AB887X", + "73447": "AB890X", + "73448": "AB887X", + "73449": "AB887X", + "73450": "AB890X", + "73452": "AB887X", + "73453": "AB887X", + "73455": "AB890X", + "73456": "AB890X", + "73458": "AB887X", + "73459": "AB887X", + "73460": "AB890X", + "73461": "AB890X", + "73463": "AB887X", + "73481": "AB887X", + "73487": "AB887X", + "73488": "AB887X", + "73491": "AB890X", + "73501": "AB890X", + "73502": "AB890X", + "73503": "AB890X", + "73505": "AB890X", + "73506": "AB890X", + "73507": "AB890X", + "73520": "AB890X", + "73521": "AB890X", + "73522": "AB890X", + "73523": "AB890X", + "73526": "AB890X", + "73527": "AB890X", + "73528": "AB890X", + "73529": "AB890X", + "73530": "AB890X", + "73531": "AB890X", + "73532": "AB890X", + "73533": "AB890X", + "73534": "AB890X", + "73536": "AB890X", + "73537": "AB890X", + "73538": "AB890X", + "73539": "AB890X", + "73540": "AB890X", + "73541": "AB890X", + "73542": "AB890X", + "73543": "AB890X", + "73544": "AB890X", + "73546": "AB890X", + "73547": "AB890X", + "73548": "AB890X", + "73549": "AB890X", + "73550": "AB890X", + "73551": "AB890X", + "73552": "AB890X", + "73553": "AB890X", + "73554": "AB890X", + "73555": "AB890X", + "73556": "AB890X", + "73557": "AB890X", + "73558": "AB890X", + "73559": "AB900X", + "73560": "AB890X", + "73561": "AB890X", + "73562": "AB890X", + "73564": "AB900X", + "73565": "AB890X", + "73566": "AB900X", + "73567": "AB890X", + "73568": "AB890X", + "73569": "AB890X", + "73570": "AB890X", + "73571": "AB890X", + "73572": "AB890X", + "73573": "AB890X", + "73601": "AB890X", + "73620": "AB890X", + "73622": "AB890X", + "73624": "AB890X", + "73625": "AB890X", + "73626": "AB890X", + "73627": "AB890X", + "73628": "AB890X", + "73632": "AB890X", + "73638": "AB890X", + "73639": "AB890X", + "73641": "AB890X", + "73642": "AB890X", + "73644": "AB890X", + "73645": "AB890X", + "73646": "AB890X", + "73647": "AB890X", + "73648": "AB890X", + "73650": "AB890X", + "73651": "AB890X", + "73654": "AB890X", + "73655": "AB890X", + "73658": "AB890X", + "73659": "AB890X", + "73660": "AB890X", + "73661": "AB890X", + "73662": "AB890X", + "73663": "AB890X", + "73664": "AB890X", + "73666": "AB890X", + "73667": "AB890X", + "73668": "AB890X", + "73669": "AB890X", + "73673": "AB890X", + "73701": "AB890X", + "73702": "AB890X", + "73703": "AB890X", + "73705": "AB890X", + "73706": "AB890X", + "73716": "AB890X", + "73717": "AB890X", + "73718": "AB890X", + "73719": "AB890X", + "73720": "AB890X", + "73722": "AB890X", + "73724": "AB890X", + "73726": "AB890X", + "73727": "AB890X", + "73728": "AB890X", + "73729": "AB890X", + "73730": "AB890X", + "73731": "AB890X", + "73733": "AB890X", + "73734": "AB890X", + "73735": "AB890X", + "73736": "AB890X", + "73737": "AB890X", + "73738": "AB890X", + "73739": "AB890X", + "73741": "AB890X", + "73742": "AB890X", + "73743": "AB890X", + "73744": "AB890X", + "73746": "AB890X", + "73747": "AB890X", + "73748": "AB890X", + "73749": "AB890X", + "73750": "AB890X", + "73753": "AB890X", + "73754": "AB890X", + "73755": "AB890X", + "73756": "AB890X", + "73757": "AB890X", + "73758": "AB890X", + "73759": "AB890X", + "73760": "AB890X", + "73761": "AB890X", + "73762": "AB890X", + "73763": "AB890X", + "73764": "AB890X", + "73766": "AB890X", + "73768": "AB890X", + "73770": "AB890X", + "73771": "AB890X", + "73772": "AB890X", + "73773": "AB890X", + "73801": "AB890X", + "73802": "AB890X", + "73832": "AB890X", + "73834": "AB890X", + "73835": "AB890X", + "73838": "AB890X", + "73840": "AB890X", + "73841": "AB890X", + "73842": "AB890X", + "73843": "AB890X", + "73844": "AB888X", + "73848": "AB890X", + "73851": "AB890X", + "73852": "AB890X", + "73853": "AB890X", + "73855": "AB890X", + "73857": "AB890X", + "73858": "AB890X", + "73859": "AB890X", + "73860": "AB890X", + "73901": "AB900X", + "73931": "AB888X", + "73932": "AB888X", + "73933": "AB890X", + "73937": "AB890X", + "73938": "AB888X", + "73939": "AB900X", + "73942": "AB900X", + "73944": "AB900X", + "73945": "AB900X", + "73946": "AB890X", + "73947": "AB890X", + "73948": "AB900X", + "73949": "AB900X", + "73950": "AB888X", + "73951": "AB900X", + "73958": "AB890X", + "74001": "AB890X", + "74002": "AB890X", + "74003": "AB890X", + "74004": "AB890X", + "74005": "AB890X", + "74006": "AB890X", + "74008": "AB890X", + "74010": "AB890X", + "74011": "AB890X", + "74012": "AB890X", + "74013": "AB890X", + "74014": "AB890X", + "74015": "AB890X", + "74016": "AB890X", + "74017": "AB890X", + "74018": "AB890X", + "74019": "AB890X", + "74020": "AB890X", + "74021": "AB890X", + "74022": "AB890X", + "74023": "AB890X", + "74026": "AB890X", + "74027": "AB890X", + "74028": "AB890X", + "74029": "AB890X", + "74030": "AB890X", + "74031": "AB890X", + "74032": "AB890X", + "74033": "AB890X", + "74034": "AB890X", + "74035": "AB890X", + "74036": "AB890X", + "74037": "AB890X", + "74038": "AB890X", + "74039": "AB890X", + "74041": "AB890X", + "74042": "AB890X", + "74043": "AB890X", + "74044": "AB890X", + "74045": "AB890X", + "74046": "AB890X", + "74047": "AB890X", + "74048": "AB890X", + "74050": "AB890X", + "74051": "AB890X", + "74052": "AB890X", + "74053": "AB890X", + "74054": "AB890X", + "74055": "AB890X", + "74056": "AB890X", + "74058": "AB890X", + "74059": "AB890X", + "74060": "AB890X", + "74061": "AB890X", + "74062": "AB890X", + "74063": "AB890X", + "74066": "AB890X", + "74067": "AB890X", + "74068": "AB890X", + "74070": "AB890X", + "74071": "AB890X", + "74072": "AB890X", + "74073": "AB890X", + "74074": "AB890X", + "74075": "AB890X", + "74076": "AB890X", + "74077": "AB890X", + "74078": "AB890X", + "74079": "AB890X", + "74080": "AB890X", + "74081": "AB890X", + "74082": "AB890X", + "74083": "AB890X", + "74084": "AB890X", + "74085": "AB890X", + "74087": "AB890X", + "74100": "AB890X", + "74101": "AB890X", + "74102": "AB890X", + "74103": "AB890X", + "74104": "AB890X", + "74105": "AB890X", + "74106": "AB890X", + "74107": "AB890X", + "74108": "AB890X", + "74110": "AB890X", + "74112": "AB890X", + "74114": "AB890X", + "74115": "AB890X", + "74116": "AB890X", + "74117": "AB890X", + "74119": "AB890X", + "74120": "AB890X", + "74121": "AB890X", + "74126": "AB890X", + "74127": "AB890X", + "74128": "AB890X", + "74129": "AB890X", + "74130": "AB890X", + "74131": "AB890X", + "74132": "AB890X", + "74133": "AB890X", + "74134": "AB890X", + "74135": "AB890X", + "74136": "AB890X", + "74137": "AB890X", + "74141": "AB890X", + "74145": "AB890X", + "74146": "AB890X", + "74147": "AB890X", + "74148": "AB890X", + "74149": "AB890X", + "74150": "AB890X", + "74152": "AB890X", + "74153": "AB890X", + "74154": "AB890X", + "74155": "AB890X", + "74156": "AB890X", + "74157": "AB890X", + "74158": "AB890X", + "74159": "AB890X", + "74169": "AB890X", + "74170": "AB890X", + "74171": "AB890X", + "74172": "AB890X", + "74182": "AB890X", + "74183": "AB890X", + "74184": "AB890X", + "74186": "AB890X", + "74187": "AB890X", + "74189": "AB890X", + "74192": "AB890X", + "74193": "AB890X", + "74194": "AB890X", + "74301": "AB890X", + "74330": "AB890X", + "74331": "AB890X", + "74332": "AB890X", + "74333": "AB890X", + "74335": "AB890X", + "74337": "AB890X", + "74338": "AB890X", + "74339": "AB890X", + "74340": "AB890X", + "74342": "AB890X", + "74343": "AB890X", + "74344": "AB890X", + "74345": "AB890X", + "74346": "AB890X", + "74347": "AB890X", + "74349": "AB890X", + "74350": "AB890X", + "74352": "AB890X", + "74354": "AB890X", + "74355": "AB890X", + "74358": "AB890X", + "74359": "AB890X", + "74360": "AB890X", + "74361": "AB890X", + "74362": "AB890X", + "74363": "AB890X", + "74364": "AB890X", + "74365": "AB890X", + "74366": "AB890X", + "74367": "AB890X", + "74368": "AB890X", + "74369": "AB890X", + "74370": "AB890X", + "74401": "AB890X", + "74402": "AB890X", + "74403": "AB890X", + "74421": "AB890X", + "74422": "AB890X", + "74423": "AB890X", + "74425": "AB890X", + "74426": "AB890X", + "74427": "AB890X", + "74428": "AB890X", + "74429": "AB890X", + "74430": "AB890X", + "74431": "AB890X", + "74432": "AB890X", + "74434": "AB890X", + "74435": "AB890X", + "74436": "AB890X", + "74437": "AB890X", + "74438": "AB890X", + "74439": "AB890X", + "74440": "AB890X", + "74441": "AB890X", + "74442": "AB890X", + "74444": "AB890X", + "74445": "AB890X", + "74446": "AB890X", + "74447": "AB890X", + "74450": "AB890X", + "74451": "AB890X", + "74452": "AB890X", + "74454": "AB890X", + "74455": "AB890X", + "74456": "AB890X", + "74457": "AB890X", + "74458": "AB890X", + "74459": "AB890X", + "74460": "AB890X", + "74461": "AB890X", + "74462": "AB890X", + "74463": "AB890X", + "74464": "AB890X", + "74465": "AB890X", + "74466": "AB890X", + "74467": "AB890X", + "74468": "AB890X", + "74469": "AB890X", + "74470": "AB890X", + "74471": "AB890X", + "74472": "AB890X", + "74477": "AB890X", + "74501": "AB890X", + "74502": "AB890X", + "74521": "AB890X", + "74522": "AB890X", + "74523": "AB890X", + "74525": "AB887X", + "74528": "AB890X", + "74529": "AB890X", + "74530": "AB890X", + "74531": "AB890X", + "74533": "AB887X", + "74534": "AB887X", + "74535": "AB887X", + "74536": "AB890X", + "74538": "AB887X", + "74540": "AB887X", + "74542": "AB887X", + "74543": "AB890X", + "74545": "AB890X", + "74546": "AB890X", + "74547": "AB890X", + "74549": "AB890X", + "74552": "AB890X", + "74553": "AB890X", + "74554": "AB890X", + "74555": "AB887X", + "74556": "AB887X", + "74557": "AB890X", + "74558": "AB890X", + "74559": "AB890X", + "74560": "AB890X", + "74561": "AB890X", + "74562": "AB890X", + "74563": "AB890X", + "74565": "AB890X", + "74567": "AB890X", + "74569": "AB887X", + "74570": "AB890X", + "74571": "AB890X", + "74572": "AB887X", + "74574": "AB890X", + "74576": "AB890X", + "74577": "AB890X", + "74578": "AB890X", + "74601": "AB890X", + "74602": "AB890X", + "74604": "AB890X", + "74630": "AB890X", + "74631": "AB890X", + "74632": "AB890X", + "74633": "AB890X", + "74636": "AB890X", + "74637": "AB890X", + "74640": "AB890X", + "74641": "AB890X", + "74643": "AB890X", + "74644": "AB890X", + "74646": "AB890X", + "74647": "AB890X", + "74650": "AB890X", + "74651": "AB890X", + "74652": "AB890X", + "74653": "AB890X", + "74701": "AB887X", + "74702": "AB887X", + "74720": "AB887X", + "74721": "AB887X", + "74722": "AB890X", + "74723": "AB887X", + "74724": "AB890X", + "74726": "AB887X", + "74727": "AB890X", + "74728": "AB890X", + "74729": "AB887X", + "74730": "AB887X", + "74731": "AB887X", + "74733": "AB887X", + "74734": "AB890X", + "74735": "AB890X", + "74736": "AB890X", + "74737": "AB890X", + "74738": "AB890X", + "74740": "AB890X", + "74741": "AB887X", + "74743": "AB890X", + "74745": "AB890X", + "74747": "AB887X", + "74748": "AB890X", + "74750": "AB890X", + "74752": "AB890X", + "74753": "AB887X", + "74754": "AB890X", + "74755": "AB890X", + "74756": "AB890X", + "74759": "AB890X", + "74760": "AB890X", + "74761": "AB890X", + "74764": "AB890X", + "74766": "AB890X", + "74801": "AB890X", + "74802": "AB890X", + "74804": "AB890X", + "74818": "AB890X", + "74820": "AB890X", + "74821": "AB890X", + "74824": "AB890X", + "74825": "AB890X", + "74826": "AB890X", + "74827": "AB890X", + "74829": "AB890X", + "74830": "AB890X", + "74831": "AB890X", + "74832": "AB890X", + "74833": "AB890X", + "74834": "AB890X", + "74836": "AB890X", + "74837": "AB890X", + "74839": "AB890X", + "74840": "AB890X", + "74842": "AB890X", + "74843": "AB890X", + "74844": "AB890X", + "74845": "AB890X", + "74848": "AB890X", + "74849": "AB890X", + "74850": "AB890X", + "74851": "AB890X", + "74852": "AB890X", + "74854": "AB890X", + "74855": "AB890X", + "74856": "AB890X", + "74857": "AB890X", + "74859": "AB890X", + "74860": "AB890X", + "74864": "AB890X", + "74865": "AB890X", + "74866": "AB890X", + "74867": "AB890X", + "74868": "AB890X", + "74869": "AB890X", + "74871": "AB890X", + "74872": "AB890X", + "74873": "AB890X", + "74875": "AB890X", + "74878": "AB890X", + "74880": "AB890X", + "74881": "AB890X", + "74883": "AB890X", + "74884": "AB890X", + "74901": "AB890X", + "74902": "AB890X", + "74930": "AB890X", + "74931": "AB890X", + "74932": "AB890X", + "74935": "AB890X", + "74936": "AB890X", + "74937": "AB890X", + "74939": "AB890X", + "74940": "AB890X", + "74941": "AB890X", + "74942": "AB890X", + "74943": "AB890X", + "74944": "AB890X", + "74945": "AB890X", + "74946": "AB890X", + "74947": "AB890X", + "74948": "AB890X", + "74949": "AB890X", + "74951": "AB890X", + "74953": "AB890X", + "74954": "AB890X", + "74955": "AB890X", + "74956": "AB890X", + "74957": "AB890X", + "74959": "AB890X", + "74960": "AB890X", + "74962": "AB890X", + "74963": "AB890X", + "74964": "AB890X", + "74965": "AB890X", + "74966": "AB890X", + "75001": "AB887X", + "75002": "AB887X", + "75006": "AB887X", + "75007": "AB887X", + "75009": "AB887X", + "75010": "AB887X", + "75011": "AB887X", + "75013": "AB887X", + "75014": "AB887X", + "75015": "AB887X", + "75016": "AB887X", + "75017": "AB887X", + "75019": "AB887X", + "75020": "AB887X", + "75021": "AB887X", + "75022": "AB887X", + "75023": "AB887X", + "75024": "AB887X", + "75025": "AB887X", + "75026": "AB887X", + "75027": "AB887X", + "75028": "AB887X", + "75029": "AB887X", + "75030": "AB887X", + "75032": "AB887X", + "75033": "AB887X", + "75034": "AB887X", + "75035": "AB887X", + "75037": "AB887X", + "75038": "AB887X", + "75039": "AB887X", + "75040": "AB887X", + "75041": "AB887X", + "75042": "AB887X", + "75043": "AB887X", + "75044": "AB887X", + "75045": "AB887X", + "75046": "AB887X", + "75047": "AB887X", + "75048": "AB887X", + "75049": "AB887X", + "75050": "AB887X", + "75051": "AB887X", + "75052": "AB887X", + "75053": "AB887X", + "75054": "AB887X", + "75056": "AB887X", + "75057": "AB887X", + "75058": "AB887X", + "75060": "AB887X", + "75061": "AB887X", + "75062": "AB887X", + "75063": "AB887X", + "75065": "AB887X", + "75067": "AB887X", + "75068": "AB887X", + "75069": "AB887X", + "75070": "AB887X", + "75071": "AB887X", + "75074": "AB887X", + "75075": "AB887X", + "75076": "AB887X", + "75077": "AB887X", + "75078": "AB887X", + "75080": "AB887X", + "75081": "AB887X", + "75082": "AB887X", + "75083": "AB887X", + "75085": "AB887X", + "75086": "AB887X", + "75087": "AB887X", + "75088": "AB887X", + "75089": "AB887X", + "75090": "AB887X", + "75091": "AB887X", + "75092": "AB887X", + "75093": "AB887X", + "75094": "AB887X", + "75097": "AB887X", + "75098": "AB887X", + "75099": "AB887X", + "75101": "AB887X", + "75102": "AB887X", + "75103": "AB887X", + "75104": "AB887X", + "75105": "AB887X", + "75106": "AB887X", + "75109": "AB887X", + "75110": "AB887X", + "75114": "AB887X", + "75115": "AB887X", + "75116": "AB887X", + "75117": "AB887X", + "75118": "AB887X", + "75119": "AB887X", + "75120": "AB887X", + "75121": "AB887X", + "75123": "AB887X", + "75124": "AB887X", + "75125": "AB887X", + "75126": "AB887X", + "75127": "AB887X", + "75132": "AB887X", + "75134": "AB887X", + "75135": "AB887X", + "75137": "AB887X", + "75138": "AB887X", + "75140": "AB887X", + "75141": "AB887X", + "75142": "AB887X", + "75143": "AB887X", + "75144": "AB887X", + "75146": "AB887X", + "75147": "AB887X", + "75148": "AB887X", + "75149": "AB887X", + "75150": "AB887X", + "75151": "AB887X", + "75152": "AB887X", + "75153": "AB887X", + "75154": "AB887X", + "75155": "AB887X", + "75156": "AB887X", + "75157": "AB887X", + "75158": "AB887X", + "75159": "AB887X", + "75160": "AB887X", + "75161": "AB887X", + "75163": "AB887X", + "75164": "AB887X", + "75165": "AB887X", + "75166": "AB887X", + "75167": "AB887X", + "75168": "AB887X", + "75169": "AB887X", + "75172": "AB887X", + "75173": "AB887X", + "75180": "AB887X", + "75181": "AB887X", + "75182": "AB887X", + "75185": "AB887X", + "75187": "AB887X", + "75189": "AB887X", + "75201": "AB887X", + "75202": "AB887X", + "75203": "AB887X", + "75204": "AB887X", + "75205": "AB887X", + "75206": "AB887X", + "75207": "AB887X", + "75208": "AB887X", + "75209": "AB887X", + "75210": "AB887X", + "75211": "AB887X", + "75212": "AB887X", + "75214": "AB887X", + "75215": "AB887X", + "75216": "AB887X", + "75217": "AB887X", + "75218": "AB887X", + "75219": "AB887X", + "75220": "AB887X", + "75221": "AB887X", + "75222": "AB887X", + "75223": "AB887X", + "75224": "AB887X", + "75225": "AB887X", + "75226": "AB887X", + "75227": "AB887X", + "75228": "AB887X", + "75229": "AB887X", + "75230": "AB887X", + "75231": "AB887X", + "75232": "AB887X", + "75233": "AB887X", + "75234": "AB887X", + "75235": "AB887X", + "75236": "AB887X", + "75237": "AB887X", + "75238": "AB887X", + "75240": "AB887X", + "75241": "AB887X", + "75242": "AB887X", + "75243": "AB887X", + "75244": "AB887X", + "75245": "AB887X", + "75246": "AB887X", + "75247": "AB887X", + "75248": "AB887X", + "75249": "AB887X", + "75250": "AB887X", + "75251": "AB887X", + "75252": "AB887X", + "75253": "AB887X", + "75254": "AB887X", + "75258": "AB887X", + "75260": "AB887X", + "75261": "AB887X", + "75262": "AB887X", + "75263": "AB887X", + "75264": "AB887X", + "75265": "AB887X", + "75266": "AB887X", + "75267": "AB887X", + "75270": "AB887X", + "75275": "AB887X", + "75277": "AB887X", + "75283": "AB887X", + "75284": "AB887X", + "75285": "AB887X", + "75286": "AB887X", + "75287": "AB887X", + "75301": "AB887X", + "75303": "AB887X", + "75310": "AB887X", + "75312": "AB887X", + "75313": "AB887X", + "75315": "AB887X", + "75320": "AB887X", + "75323": "AB887X", + "75326": "AB887X", + "75334": "AB887X", + "75336": "AB887X", + "75339": "AB887X", + "75340": "AB887X", + "75342": "AB887X", + "75343": "AB887X", + "75344": "AB887X", + "75353": "AB887X", + "75354": "AB887X", + "75355": "AB887X", + "75356": "AB887X", + "75357": "AB887X", + "75358": "AB887X", + "75359": "AB887X", + "75360": "AB887X", + "75363": "AB887X", + "75364": "AB887X", + "75367": "AB887X", + "75368": "AB887X", + "75370": "AB887X", + "75371": "AB887X", + "75372": "AB887X", + "75373": "AB887X", + "75374": "AB887X", + "75376": "AB887X", + "75378": "AB887X", + "75379": "AB887X", + "75380": "AB887X", + "75381": "AB887X", + "75382": "AB887X", + "75386": "AB887X", + "75387": "AB887X", + "75388": "AB887X", + "75389": "AB887X", + "75390": "AB887X", + "75391": "AB887X", + "75392": "AB887X", + "75393": "AB887X", + "75394": "AB887X", + "75395": "AB887X", + "75396": "AB887X", + "75397": "AB887X", + "75398": "AB887X", + "75401": "AB887X", + "75402": "AB887X", + "75403": "AB887X", + "75404": "AB887X", + "75407": "AB887X", + "75409": "AB887X", + "75410": "AB888X", + "75411": "AB887X", + "75412": "AB887X", + "75413": "AB887X", + "75414": "AB887X", + "75415": "AB887X", + "75416": "AB887X", + "75417": "AB887X", + "75418": "AB887X", + "75420": "AB887X", + "75421": "AB887X", + "75422": "AB887X", + "75423": "AB887X", + "75424": "AB887X", + "75425": "AB887X", + "75426": "AB887X", + "75428": "AB887X", + "75429": "AB887X", + "75431": "AB887X", + "75432": "AB887X", + "75433": "AB887X", + "75434": "AB887X", + "75435": "AB887X", + "75436": "AB887X", + "75437": "AB887X", + "75438": "AB887X", + "75439": "AB887X", + "75440": "AB887X", + "75441": "AB887X", + "75442": "AB887X", + "75443": "AB887X", + "75444": "AB888X", + "75446": "AB887X", + "75447": "AB887X", + "75448": "AB887X", + "75449": "AB887X", + "75450": "AB887X", + "75451": "AB888X", + "75452": "AB887X", + "75453": "AB887X", + "75454": "AB887X", + "75455": "AB888X", + "75456": "AB888X", + "75457": "AB887X", + "75458": "AB887X", + "75459": "AB887X", + "75460": "AB887X", + "75461": "AB887X", + "75462": "AB887X", + "75468": "AB887X", + "75469": "AB887X", + "75470": "AB887X", + "75471": "AB887X", + "75472": "AB887X", + "75473": "AB887X", + "75474": "AB887X", + "75475": "AB887X", + "75476": "AB887X", + "75477": "AB887X", + "75478": "AB887X", + "75479": "AB887X", + "75480": "AB887X", + "75481": "AB887X", + "75482": "AB887X", + "75483": "AB887X", + "75485": "AB887X", + "75486": "AB887X", + "75487": "AB887X", + "75488": "AB887X", + "75489": "AB887X", + "75490": "AB887X", + "75491": "AB887X", + "75492": "AB887X", + "75493": "AB888X", + "75494": "AB888X", + "75495": "AB887X", + "75496": "AB887X", + "75497": "AB888X", + "75501": "AB888X", + "75503": "AB888X", + "75504": "AB888X", + "75505": "AB888X", + "75507": "AB888X", + "75550": "AB887X", + "75551": "AB888X", + "75554": "AB887X", + "75555": "AB888X", + "75556": "AB888X", + "75558": "AB888X", + "75559": "AB888X", + "75560": "AB888X", + "75561": "AB888X", + "75562": "AB888X", + "75563": "AB888X", + "75564": "AB888X", + "75565": "AB888X", + "75566": "AB888X", + "75567": "AB888X", + "75568": "AB888X", + "75569": "AB888X", + "75570": "AB888X", + "75571": "AB888X", + "75572": "AB888X", + "75573": "AB888X", + "75574": "AB888X", + "75599": "AB888X", + "75601": "AB888X", + "75602": "AB888X", + "75603": "AB888X", + "75604": "AB888X", + "75605": "AB888X", + "75606": "AB888X", + "75607": "AB888X", + "75608": "AB888X", + "75615": "AB888X", + "75630": "AB888X", + "75631": "AB888X", + "75633": "AB888X", + "75636": "AB888X", + "75637": "AB888X", + "75638": "AB888X", + "75639": "AB888X", + "75640": "AB888X", + "75641": "AB888X", + "75642": "AB888X", + "75643": "AB888X", + "75644": "AB888X", + "75645": "AB888X", + "75647": "AB888X", + "75650": "AB888X", + "75651": "AB888X", + "75652": "AB888X", + "75653": "AB888X", + "75654": "AB888X", + "75656": "AB888X", + "75657": "AB888X", + "75658": "AB888X", + "75659": "AB888X", + "75660": "AB888X", + "75661": "AB888X", + "75662": "AB888X", + "75663": "AB888X", + "75666": "AB888X", + "75667": "AB888X", + "75668": "AB888X", + "75669": "AB888X", + "75670": "AB888X", + "75671": "AB888X", + "75672": "AB888X", + "75680": "AB888X", + "75681": "AB888X", + "75682": "AB888X", + "75683": "AB888X", + "75684": "AB888X", + "75685": "AB888X", + "75686": "AB888X", + "75687": "AB888X", + "75688": "AB888X", + "75689": "AB888X", + "75691": "AB888X", + "75692": "AB888X", + "75693": "AB888X", + "75694": "AB888X", + "75701": "AB888X", + "75702": "AB888X", + "75703": "AB888X", + "75704": "AB888X", + "75705": "AB888X", + "75706": "AB888X", + "75707": "AB888X", + "75708": "AB888X", + "75709": "AB888X", + "75710": "AB888X", + "75711": "AB888X", + "75712": "AB888X", + "75713": "AB888X", + "75750": "AB888X", + "75751": "AB887X", + "75752": "AB887X", + "75754": "AB887X", + "75755": "AB888X", + "75756": "AB887X", + "75757": "AB888X", + "75758": "AB887X", + "75759": "AB888X", + "75760": "AB888X", + "75762": "AB888X", + "75763": "AB887X", + "75764": "AB888X", + "75765": "AB888X", + "75766": "AB888X", + "75770": "AB887X", + "75771": "AB888X", + "75772": "AB888X", + "75773": "AB888X", + "75778": "AB887X", + "75779": "AB887X", + "75780": "AB888X", + "75782": "AB887X", + "75783": "AB888X", + "75784": "AB888X", + "75785": "AB888X", + "75788": "AB888X", + "75789": "AB888X", + "75790": "AB887X", + "75791": "AB888X", + "75792": "AB888X", + "75797": "AB888X", + "75798": "AB888X", + "75799": "AB888X", + "75801": "AB887X", + "75802": "AB887X", + "75803": "AB887X", + "75831": "AB890X", + "75832": "AB887X", + "75833": "AB890X", + "75834": "AB890X", + "75835": "AB888X", + "75838": "AB890X", + "75839": "AB887X", + "75840": "AB890X", + "75844": "AB888X", + "75845": "AB890X", + "75846": "AB890X", + "75847": "AB888X", + "75848": "AB890X", + "75849": "AB888X", + "75850": "AB890X", + "75851": "AB888X", + "75852": "AB890X", + "75853": "AB887X", + "75855": "AB890X", + "75856": "AB890X", + "75858": "AB888X", + "75859": "AB890X", + "75860": "AB890X", + "75861": "AB887X", + "75862": "AB890X", + "75865": "AB890X", + "75880": "AB887X", + "75882": "AB887X", + "75884": "AB887X", + "75886": "AB887X", + "75901": "AB888X", + "75902": "AB888X", + "75903": "AB888X", + "75904": "AB888X", + "75915": "AB888X", + "75925": "AB888X", + "75926": "AB890X", + "75928": "AB890X", + "75929": "AB888X", + "75930": "AB888X", + "75931": "AB890X", + "75932": "AB890X", + "75933": "AB890X", + "75934": "AB890X", + "75935": "AB888X", + "75936": "AB890X", + "75937": "AB888X", + "75938": "AB890X", + "75939": "AB890X", + "75941": "AB888X", + "75942": "AB890X", + "75943": "AB888X", + "75944": "AB888X", + "75946": "AB888X", + "75948": "AB888X", + "75949": "AB888X", + "75951": "AB890X", + "75954": "AB888X", + "75956": "AB890X", + "75958": "AB888X", + "75959": "AB888X", + "75960": "AB890X", + "75961": "AB888X", + "75962": "AB888X", + "75963": "AB888X", + "75964": "AB888X", + "75965": "AB888X", + "75966": "AB890X", + "75968": "AB888X", + "75969": "AB888X", + "75972": "AB888X", + "75973": "AB888X", + "75974": "AB888X", + "75975": "AB888X", + "75976": "AB888X", + "75977": "AB890X", + "75978": "AB888X", + "75979": "AB890X", + "75980": "AB888X", + "75990": "AB890X", + "76001": "AB887X", + "76002": "AB887X", + "76003": "AB887X", + "76004": "AB887X", + "76005": "AB887X", + "76006": "AB887X", + "76007": "AB887X", + "76008": "AB887X", + "76009": "AB887X", + "76010": "AB887X", + "76011": "AB887X", + "76012": "AB887X", + "76013": "AB887X", + "76014": "AB887X", + "76015": "AB887X", + "76016": "AB887X", + "76017": "AB887X", + "76018": "AB887X", + "76019": "AB887X", + "76020": "AB887X", + "76021": "AB887X", + "76022": "AB887X", + "76023": "AB887X", + "76028": "AB887X", + "76031": "AB887X", + "76033": "AB887X", + "76034": "AB887X", + "76035": "AB887X", + "76036": "AB887X", + "76039": "AB887X", + "76040": "AB887X", + "76041": "AB887X", + "76043": "AB887X", + "76044": "AB887X", + "76048": "AB887X", + "76049": "AB887X", + "76050": "AB887X", + "76051": "AB887X", + "76052": "AB887X", + "76053": "AB887X", + "76054": "AB887X", + "76055": "AB887X", + "76058": "AB887X", + "76059": "AB887X", + "76060": "AB887X", + "76061": "AB887X", + "76063": "AB887X", + "76064": "AB887X", + "76065": "AB887X", + "76066": "AB887X", + "76067": "AB887X", + "76068": "AB887X", + "76070": "AB887X", + "76071": "AB887X", + "76073": "AB887X", + "76077": "AB887X", + "76078": "AB887X", + "76082": "AB887X", + "76084": "AB887X", + "76085": "AB887X", + "76086": "AB887X", + "76087": "AB887X", + "76088": "AB887X", + "76092": "AB887X", + "76093": "AB887X", + "76094": "AB887X", + "76095": "AB887X", + "76096": "AB887X", + "76097": "AB887X", + "76098": "AB887X", + "76099": "AB887X", + "76101": "AB887X", + "76102": "AB887X", + "76103": "AB887X", + "76104": "AB887X", + "76105": "AB887X", + "76106": "AB887X", + "76107": "AB887X", + "76108": "AB887X", + "76109": "AB887X", + "76110": "AB887X", + "76111": "AB887X", + "76112": "AB887X", + "76113": "AB887X", + "76114": "AB887X", + "76115": "AB887X", + "76116": "AB887X", + "76117": "AB887X", + "76118": "AB887X", + "76119": "AB887X", + "76120": "AB887X", + "76121": "AB887X", + "76122": "AB887X", + "76123": "AB887X", + "76124": "AB887X", + "76126": "AB887X", + "76127": "AB887X", + "76129": "AB887X", + "76130": "AB887X", + "76131": "AB887X", + "76132": "AB887X", + "76133": "AB887X", + "76134": "AB887X", + "76135": "AB887X", + "76136": "AB887X", + "76137": "AB887X", + "76140": "AB887X", + "76147": "AB887X", + "76148": "AB887X", + "76150": "AB887X", + "76155": "AB887X", + "76161": "AB887X", + "76162": "AB887X", + "76163": "AB887X", + "76164": "AB887X", + "76177": "AB887X", + "76179": "AB887X", + "76180": "AB887X", + "76181": "AB887X", + "76182": "AB887X", + "76185": "AB887X", + "76191": "AB887X", + "76192": "AB887X", + "76193": "AB887X", + "76195": "AB887X", + "76196": "AB887X", + "76197": "AB887X", + "76198": "AB887X", + "76199": "AB887X", + "76201": "AB887X", + "76202": "AB887X", + "76203": "AB887X", + "76204": "AB887X", + "76205": "AB887X", + "76206": "AB887X", + "76207": "AB887X", + "76208": "AB887X", + "76209": "AB887X", + "76210": "AB887X", + "76225": "AB887X", + "76226": "AB887X", + "76227": "AB887X", + "76228": "AB900X", + "76230": "AB900X", + "76233": "AB887X", + "76234": "AB887X", + "76238": "AB887X", + "76239": "AB900X", + "76240": "AB887X", + "76241": "AB887X", + "76244": "AB887X", + "76245": "AB887X", + "76246": "AB887X", + "76247": "AB887X", + "76248": "AB887X", + "76249": "AB887X", + "76250": "AB887X", + "76251": "AB900X", + "76252": "AB887X", + "76253": "AB887X", + "76255": "AB900X", + "76258": "AB887X", + "76259": "AB887X", + "76261": "AB900X", + "76262": "AB887X", + "76263": "AB887X", + "76264": "AB887X", + "76265": "AB900X", + "76266": "AB887X", + "76267": "AB887X", + "76268": "AB887X", + "76270": "AB900X", + "76271": "AB887X", + "76272": "AB887X", + "76273": "AB887X", + "76299": "AB887X", + "76301": "AB900X", + "76302": "AB900X", + "76305": "AB900X", + "76306": "AB900X", + "76307": "AB900X", + "76308": "AB900X", + "76309": "AB900X", + "76310": "AB900X", + "76311": "AB900X", + "76351": "AB900X", + "76352": "AB900X", + "76354": "AB900X", + "76357": "AB900X", + "76360": "AB900X", + "76363": "AB900X", + "76364": "AB900X", + "76365": "AB900X", + "76366": "AB900X", + "76367": "AB900X", + "76369": "AB900X", + "76370": "AB900X", + "76371": "AB900X", + "76372": "AB900X", + "76373": "AB900X", + "76374": "AB900X", + "76377": "AB900X", + "76379": "AB900X", + "76380": "AB900X", + "76384": "AB900X", + "76385": "AB900X", + "76388": "AB900X", + "76389": "AB900X", + "76401": "AB887X", + "76402": "AB887X", + "76424": "AB900X", + "76426": "AB887X", + "76427": "AB900X", + "76429": "AB900X", + "76430": "AB900X", + "76431": "AB887X", + "76432": "AB900X", + "76433": "AB887X", + "76435": "AB900X", + "76436": "AB887X", + "76437": "AB900X", + "76439": "AB887X", + "76442": "AB887X", + "76443": "AB900X", + "76444": "AB887X", + "76445": "AB900X", + "76446": "AB887X", + "76448": "AB900X", + "76449": "AB887X", + "76450": "AB900X", + "76452": "AB887X", + "76453": "AB887X", + "76454": "AB900X", + "76455": "AB887X", + "76457": "AB887X", + "76458": "AB900X", + "76459": "AB900X", + "76460": "AB900X", + "76461": "AB887X", + "76462": "AB887X", + "76463": "AB887X", + "76464": "AB900X", + "76465": "AB887X", + "76466": "AB900X", + "76467": "AB887X", + "76468": "AB887X", + "76469": "AB900X", + "76470": "AB900X", + "76471": "AB900X", + "76472": "AB887X", + "76474": "AB887X", + "76475": "AB887X", + "76476": "AB887X", + "76481": "AB900X", + "76483": "AB900X", + "76484": "AB887X", + "76485": "AB887X", + "76486": "AB900X", + "76487": "AB887X", + "76490": "AB887X", + "76491": "AB900X", + "76501": "AB890X", + "76502": "AB890X", + "76503": "AB890X", + "76504": "AB890X", + "76505": "AB890X", + "76508": "AB890X", + "76511": "AB890X", + "76513": "AB890X", + "76518": "AB890X", + "76519": "AB890X", + "76520": "AB890X", + "76522": "AB890X", + "76523": "AB890X", + "76524": "AB890X", + "76525": "AB890X", + "76526": "AB890X", + "76527": "AB890X", + "76528": "AB890X", + "76530": "AB890X", + "76531": "AB887X", + "76533": "AB890X", + "76534": "AB890X", + "76537": "AB890X", + "76538": "AB890X", + "76539": "AB890X", + "76540": "AB890X", + "76541": "AB890X", + "76542": "AB890X", + "76543": "AB890X", + "76544": "AB890X", + "76545": "AB890X", + "76546": "AB890X", + "76547": "AB890X", + "76548": "AB890X", + "76549": "AB890X", + "76550": "AB890X", + "76554": "AB890X", + "76556": "AB890X", + "76557": "AB890X", + "76558": "AB890X", + "76559": "AB890X", + "76561": "AB890X", + "76564": "AB890X", + "76565": "AB887X", + "76566": "AB890X", + "76567": "AB890X", + "76569": "AB890X", + "76570": "AB890X", + "76571": "AB890X", + "76573": "AB890X", + "76574": "AB890X", + "76577": "AB890X", + "76578": "AB890X", + "76579": "AB890X", + "76596": "AB890X", + "76597": "AB890X", + "76598": "AB890X", + "76599": "AB890X", + "76621": "AB887X", + "76622": "AB887X", + "76623": "AB887X", + "76624": "AB890X", + "76626": "AB887X", + "76627": "AB887X", + "76628": "AB887X", + "76629": "AB890X", + "76630": "AB890X", + "76631": "AB887X", + "76632": "AB890X", + "76633": "AB890X", + "76634": "AB890X", + "76635": "AB890X", + "76636": "AB887X", + "76637": "AB890X", + "76638": "AB890X", + "76639": "AB887X", + "76640": "AB890X", + "76641": "AB887X", + "76642": "AB890X", + "76643": "AB890X", + "76644": "AB890X", + "76645": "AB887X", + "76648": "AB887X", + "76649": "AB890X", + "76650": "AB887X", + "76651": "AB887X", + "76652": "AB890X", + "76653": "AB890X", + "76654": "AB890X", + "76655": "AB890X", + "76656": "AB890X", + "76657": "AB890X", + "76660": "AB887X", + "76661": "AB890X", + "76664": "AB890X", + "76665": "AB890X", + "76666": "AB887X", + "76667": "AB890X", + "76670": "AB887X", + "76671": "AB890X", + "76673": "AB887X", + "76676": "AB887X", + "76678": "AB890X", + "76679": "AB887X", + "76680": "AB890X", + "76681": "AB887X", + "76682": "AB890X", + "76684": "AB890X", + "76685": "AB890X", + "76686": "AB890X", + "76687": "AB890X", + "76689": "AB890X", + "76690": "AB890X", + "76691": "AB890X", + "76692": "AB887X", + "76693": "AB890X", + "76701": "AB890X", + "76702": "AB890X", + "76703": "AB890X", + "76704": "AB890X", + "76705": "AB890X", + "76706": "AB890X", + "76707": "AB890X", + "76708": "AB890X", + "76710": "AB890X", + "76711": "AB890X", + "76712": "AB890X", + "76714": "AB890X", + "76715": "AB890X", + "76716": "AB890X", + "76795": "AB890X", + "76797": "AB890X", + "76798": "AB890X", + "76799": "AB890X", + "76801": "AB900X", + "76802": "AB900X", + "76803": "AB900X", + "76804": "AB900X", + "76820": "AB900X", + "76821": "AB900X", + "76823": "AB900X", + "76824": "AB900X", + "76825": "AB900X", + "76827": "AB900X", + "76828": "AB900X", + "76831": "AB890X", + "76832": "AB900X", + "76834": "AB900X", + "76836": "AB900X", + "76837": "AB900X", + "76841": "AB900X", + "76842": "AB900X", + "76844": "AB890X", + "76845": "AB900X", + "76848": "AB900X", + "76849": "AB900X", + "76852": "AB900X", + "76853": "AB890X", + "76854": "AB900X", + "76855": "AB900X", + "76856": "AB900X", + "76857": "AB900X", + "76858": "AB900X", + "76859": "AB900X", + "76861": "AB900X", + "76862": "AB900X", + "76864": "AB890X", + "76865": "AB900X", + "76866": "AB900X", + "76869": "AB900X", + "76870": "AB890X", + "76871": "AB900X", + "76872": "AB900X", + "76873": "AB900X", + "76874": "AB900X", + "76875": "AB900X", + "76877": "AB900X", + "76878": "AB900X", + "76880": "AB890X", + "76882": "AB900X", + "76883": "AB891X", + "76884": "AB900X", + "76885": "AB890X", + "76886": "AB900X", + "76887": "AB900X", + "76888": "AB900X", + "76890": "AB900X", + "76901": "AB900X", + "76902": "AB900X", + "76903": "AB900X", + "76904": "AB900X", + "76905": "AB900X", + "76906": "AB900X", + "76908": "AB900X", + "76909": "AB900X", + "76930": "AB900X", + "76932": "AB900X", + "76933": "AB900X", + "76934": "AB900X", + "76935": "AB900X", + "76936": "AB900X", + "76937": "AB900X", + "76939": "AB900X", + "76940": "AB900X", + "76941": "AB900X", + "76943": "AB900X", + "76945": "AB900X", + "76949": "AB900X", + "76950": "AB900X", + "76951": "AB900X", + "76953": "AB900X", + "76955": "AB900X", + "76957": "AB900X", + "76958": "AB900X", + "77001": "AB890X", + "77002": "AB890X", + "77003": "AB890X", + "77004": "AB890X", + "77005": "AB890X", + "77006": "AB890X", + "77007": "AB890X", + "77008": "AB890X", + "77009": "AB890X", + "77010": "AB890X", + "77011": "AB890X", + "77012": "AB890X", + "77013": "AB890X", + "77014": "AB890X", + "77015": "AB890X", + "77016": "AB890X", + "77017": "AB890X", + "77018": "AB890X", + "77019": "AB890X", + "77020": "AB890X", + "77021": "AB890X", + "77022": "AB890X", + "77023": "AB890X", + "77024": "AB890X", + "77025": "AB890X", + "77026": "AB890X", + "77027": "AB890X", + "77028": "AB890X", + "77029": "AB890X", + "77030": "AB890X", + "77031": "AB890X", + "77032": "AB890X", + "77033": "AB890X", + "77034": "AB890X", + "77035": "AB890X", + "77036": "AB890X", + "77037": "AB890X", + "77038": "AB890X", + "77039": "AB890X", + "77040": "AB890X", + "77041": "AB890X", + "77042": "AB890X", + "77043": "AB890X", + "77044": "AB890X", + "77045": "AB890X", + "77046": "AB890X", + "77047": "AB890X", + "77048": "AB890X", + "77049": "AB890X", + "77050": "AB890X", + "77051": "AB890X", + "77052": "AB890X", + "77053": "AB890X", + "77054": "AB890X", + "77055": "AB890X", + "77056": "AB890X", + "77057": "AB890X", + "77058": "AB890X", + "77059": "AB890X", + "77060": "AB890X", + "77061": "AB890X", + "77062": "AB890X", + "77063": "AB890X", + "77064": "AB890X", + "77065": "AB890X", + "77066": "AB890X", + "77067": "AB890X", + "77068": "AB890X", + "77069": "AB890X", + "77070": "AB890X", + "77071": "AB890X", + "77072": "AB890X", + "77073": "AB890X", + "77074": "AB890X", + "77075": "AB890X", + "77076": "AB890X", + "77077": "AB890X", + "77078": "AB890X", + "77079": "AB890X", + "77080": "AB890X", + "77081": "AB890X", + "77082": "AB890X", + "77083": "AB890X", + "77084": "AB890X", + "77085": "AB890X", + "77086": "AB890X", + "77087": "AB890X", + "77088": "AB890X", + "77089": "AB890X", + "77090": "AB890X", + "77091": "AB890X", + "77092": "AB890X", + "77093": "AB890X", + "77094": "AB890X", + "77095": "AB890X", + "77096": "AB890X", + "77097": "AB890X", + "77098": "AB890X", + "77099": "AB890X", + "77201": "AB890X", + "77202": "AB890X", + "77203": "AB890X", + "77204": "AB890X", + "77205": "AB890X", + "77206": "AB890X", + "77207": "AB890X", + "77208": "AB890X", + "77209": "AB890X", + "77210": "AB890X", + "77212": "AB890X", + "77213": "AB890X", + "77215": "AB890X", + "77216": "AB890X", + "77217": "AB890X", + "77218": "AB890X", + "77219": "AB890X", + "77220": "AB890X", + "77221": "AB890X", + "77222": "AB890X", + "77223": "AB890X", + "77224": "AB890X", + "77225": "AB890X", + "77226": "AB890X", + "77227": "AB890X", + "77228": "AB890X", + "77229": "AB890X", + "77230": "AB890X", + "77231": "AB890X", + "77233": "AB890X", + "77234": "AB890X", + "77235": "AB890X", + "77236": "AB890X", + "77237": "AB890X", + "77238": "AB890X", + "77240": "AB890X", + "77241": "AB890X", + "77242": "AB890X", + "77243": "AB890X", + "77244": "AB890X", + "77245": "AB890X", + "77246": "AB890X", + "77247": "AB890X", + "77248": "AB890X", + "77249": "AB890X", + "77250": "AB890X", + "77251": "AB890X", + "77252": "AB890X", + "77253": "AB890X", + "77254": "AB890X", + "77255": "AB890X", + "77256": "AB890X", + "77257": "AB890X", + "77258": "AB890X", + "77259": "AB890X", + "77260": "AB890X", + "77261": "AB890X", + "77262": "AB890X", + "77263": "AB890X", + "77265": "AB890X", + "77266": "AB890X", + "77267": "AB890X", + "77268": "AB890X", + "77269": "AB890X", + "77270": "AB890X", + "77271": "AB890X", + "77272": "AB890X", + "77273": "AB890X", + "77274": "AB890X", + "77275": "AB890X", + "77276": "AB890X", + "77277": "AB890X", + "77278": "AB890X", + "77279": "AB890X", + "77280": "AB890X", + "77282": "AB890X", + "77284": "AB890X", + "77285": "AB890X", + "77286": "AB890X", + "77287": "AB890X", + "77288": "AB890X", + "77289": "AB890X", + "77290": "AB890X", + "77291": "AB890X", + "77292": "AB890X", + "77293": "AB890X", + "77294": "AB890X", + "77296": "AB890X", + "77297": "AB890X", + "77298": "AB890X", + "77299": "AB890X", + "77301": "AB890X", + "77302": "AB890X", + "77303": "AB890X", + "77304": "AB890X", + "77305": "AB890X", + "77306": "AB890X", + "77315": "AB890X", + "77316": "AB890X", + "77318": "AB890X", + "77320": "AB890X", + "77325": "AB890X", + "77326": "AB890X", + "77327": "AB890X", + "77328": "AB890X", + "77331": "AB890X", + "77332": "AB890X", + "77333": "AB890X", + "77334": "AB890X", + "77335": "AB890X", + "77336": "AB890X", + "77337": "AB890X", + "77338": "AB890X", + "77339": "AB890X", + "77340": "AB890X", + "77341": "AB890X", + "77342": "AB890X", + "77343": "AB890X", + "77344": "AB890X", + "77345": "AB890X", + "77346": "AB890X", + "77347": "AB890X", + "77348": "AB890X", + "77349": "AB890X", + "77350": "AB890X", + "77351": "AB890X", + "77353": "AB890X", + "77354": "AB890X", + "77355": "AB890X", + "77356": "AB890X", + "77357": "AB890X", + "77358": "AB890X", + "77359": "AB890X", + "77360": "AB890X", + "77362": "AB890X", + "77363": "AB890X", + "77364": "AB890X", + "77365": "AB890X", + "77367": "AB890X", + "77368": "AB890X", + "77369": "AB890X", + "77371": "AB890X", + "77372": "AB890X", + "77373": "AB890X", + "77374": "AB890X", + "77375": "AB890X", + "77376": "AB890X", + "77377": "AB890X", + "77378": "AB890X", + "77379": "AB890X", + "77380": "AB890X", + "77381": "AB890X", + "77382": "AB890X", + "77383": "AB890X", + "77384": "AB890X", + "77385": "AB890X", + "77386": "AB890X", + "77387": "AB890X", + "77388": "AB890X", + "77389": "AB890X", + "77391": "AB890X", + "77393": "AB890X", + "77396": "AB890X", + "77399": "AB890X", + "77401": "AB890X", + "77402": "AB890X", + "77404": "AB890X", + "77406": "AB890X", + "77410": "AB890X", + "77411": "AB890X", + "77412": "AB890X", + "77413": "AB890X", + "77414": "AB890X", + "77415": "AB890X", + "77417": "AB890X", + "77418": "AB890X", + "77419": "AB890X", + "77420": "AB890X", + "77422": "AB890X", + "77423": "AB890X", + "77426": "AB890X", + "77428": "AB890X", + "77429": "AB890X", + "77430": "AB890X", + "77431": "AB890X", + "77432": "AB890X", + "77433": "AB890X", + "77434": "AB890X", + "77435": "AB890X", + "77436": "AB890X", + "77437": "AB890X", + "77440": "AB890X", + "77441": "AB890X", + "77442": "AB890X", + "77443": "AB890X", + "77444": "AB890X", + "77445": "AB890X", + "77446": "AB890X", + "77447": "AB890X", + "77448": "AB890X", + "77449": "AB890X", + "77450": "AB890X", + "77451": "AB890X", + "77452": "AB890X", + "77453": "AB890X", + "77454": "AB890X", + "77455": "AB890X", + "77456": "AB890X", + "77457": "AB890X", + "77458": "AB890X", + "77459": "AB890X", + "77460": "AB890X", + "77461": "AB890X", + "77463": "AB890X", + "77464": "AB890X", + "77465": "AB890X", + "77466": "AB890X", + "77467": "AB890X", + "77468": "AB890X", + "77469": "AB890X", + "77470": "AB890X", + "77471": "AB890X", + "77473": "AB890X", + "77474": "AB890X", + "77475": "AB890X", + "77476": "AB890X", + "77477": "AB890X", + "77478": "AB890X", + "77479": "AB890X", + "77480": "AB890X", + "77481": "AB890X", + "77482": "AB890X", + "77483": "AB890X", + "77484": "AB890X", + "77485": "AB890X", + "77486": "AB890X", + "77487": "AB890X", + "77488": "AB890X", + "77489": "AB890X", + "77491": "AB890X", + "77492": "AB890X", + "77493": "AB890X", + "77494": "AB890X", + "77496": "AB890X", + "77497": "AB890X", + "77498": "AB890X", + "77501": "AB890X", + "77502": "AB890X", + "77503": "AB890X", + "77504": "AB890X", + "77505": "AB890X", + "77506": "AB890X", + "77507": "AB890X", + "77508": "AB890X", + "77510": "AB890X", + "77511": "AB890X", + "77512": "AB890X", + "77514": "AB890X", + "77515": "AB890X", + "77516": "AB890X", + "77517": "AB890X", + "77518": "AB890X", + "77519": "AB890X", + "77520": "AB890X", + "77521": "AB890X", + "77522": "AB890X", + "77523": "AB890X", + "77530": "AB890X", + "77531": "AB890X", + "77532": "AB890X", + "77533": "AB890X", + "77534": "AB890X", + "77535": "AB890X", + "77536": "AB890X", + "77538": "AB890X", + "77539": "AB890X", + "77541": "AB890X", + "77542": "AB890X", + "77545": "AB890X", + "77546": "AB890X", + "77547": "AB890X", + "77549": "AB890X", + "77550": "AB890X", + "77551": "AB890X", + "77552": "AB890X", + "77553": "AB890X", + "77554": "AB890X", + "77555": "AB890X", + "77560": "AB890X", + "77561": "AB890X", + "77562": "AB890X", + "77563": "AB890X", + "77564": "AB890X", + "77565": "AB890X", + "77566": "AB890X", + "77568": "AB890X", + "77571": "AB890X", + "77572": "AB890X", + "77573": "AB890X", + "77574": "AB890X", + "77575": "AB890X", + "77577": "AB890X", + "77578": "AB890X", + "77580": "AB890X", + "77581": "AB890X", + "77582": "AB890X", + "77583": "AB890X", + "77584": "AB890X", + "77585": "AB890X", + "77586": "AB890X", + "77587": "AB890X", + "77588": "AB890X", + "77590": "AB890X", + "77591": "AB890X", + "77592": "AB890X", + "77597": "AB890X", + "77598": "AB890X", + "77611": "AB890X", + "77612": "AB890X", + "77613": "AB890X", + "77614": "AB890X", + "77615": "AB890X", + "77616": "AB890X", + "77617": "AB890X", + "77619": "AB890X", + "77622": "AB890X", + "77623": "AB890X", + "77624": "AB890X", + "77625": "AB890X", + "77626": "AB890X", + "77627": "AB890X", + "77629": "AB890X", + "77630": "AB890X", + "77631": "AB890X", + "77632": "AB890X", + "77639": "AB890X", + "77640": "AB890X", + "77641": "AB890X", + "77642": "AB890X", + "77643": "AB890X", + "77650": "AB890X", + "77651": "AB890X", + "77655": "AB890X", + "77656": "AB890X", + "77657": "AB890X", + "77659": "AB890X", + "77660": "AB890X", + "77661": "AB890X", + "77662": "AB890X", + "77663": "AB890X", + "77664": "AB890X", + "77665": "AB890X", + "77670": "AB890X", + "77701": "AB890X", + "77702": "AB890X", + "77703": "AB890X", + "77704": "AB890X", + "77705": "AB890X", + "77706": "AB890X", + "77707": "AB890X", + "77708": "AB890X", + "77709": "AB890X", + "77710": "AB890X", + "77713": "AB890X", + "77720": "AB890X", + "77725": "AB890X", + "77726": "AB890X", + "77801": "AB890X", + "77802": "AB890X", + "77803": "AB890X", + "77805": "AB890X", + "77806": "AB890X", + "77807": "AB890X", + "77808": "AB890X", + "77830": "AB890X", + "77831": "AB890X", + "77833": "AB890X", + "77834": "AB890X", + "77835": "AB890X", + "77836": "AB890X", + "77837": "AB890X", + "77838": "AB890X", + "77840": "AB890X", + "77841": "AB890X", + "77842": "AB890X", + "77843": "AB890X", + "77844": "AB890X", + "77845": "AB890X", + "77850": "AB890X", + "77852": "AB890X", + "77853": "AB890X", + "77855": "AB890X", + "77856": "AB890X", + "77857": "AB890X", + "77859": "AB890X", + "77861": "AB890X", + "77862": "AB890X", + "77863": "AB890X", + "77864": "AB890X", + "77865": "AB890X", + "77866": "AB890X", + "77867": "AB890X", + "77868": "AB890X", + "77869": "AB890X", + "77870": "AB890X", + "77871": "AB890X", + "77872": "AB890X", + "77873": "AB890X", + "77875": "AB890X", + "77876": "AB890X", + "77878": "AB890X", + "77879": "AB890X", + "77880": "AB890X", + "77881": "AB890X", + "77882": "AB890X", + "77901": "AB890X", + "77902": "AB890X", + "77903": "AB890X", + "77904": "AB890X", + "77905": "AB890X", + "77950": "AB891X", + "77951": "AB890X", + "77954": "AB890X", + "77957": "AB890X", + "77960": "AB889X", + "77961": "AB890X", + "77962": "AB890X", + "77963": "AB889X", + "77964": "AB890X", + "77967": "AB890X", + "77968": "AB890X", + "77969": "AB890X", + "77970": "AB890X", + "77971": "AB890X", + "77973": "AB890X", + "77974": "AB890X", + "77975": "AB890X", + "77976": "AB890X", + "77977": "AB890X", + "77978": "AB890X", + "77979": "AB890X", + "77982": "AB890X", + "77983": "AB890X", + "77984": "AB890X", + "77986": "AB890X", + "77987": "AB890X", + "77988": "AB890X", + "77989": "AB890X", + "77990": "AB891X", + "77991": "AB890X", + "77993": "AB889X", + "77994": "AB890X", + "77995": "AB890X", + "78001": "AB891X", + "78002": "AB891X", + "78003": "AB891X", + "78004": "AB891X", + "78005": "AB891X", + "78006": "AB891X", + "78007": "AB891X", + "78008": "AB891X", + "78009": "AB891X", + "78010": "AB891X", + "78011": "AB891X", + "78012": "AB891X", + "78013": "AB891X", + "78014": "AB891X", + "78015": "AB891X", + "78016": "AB891X", + "78017": "AB891X", + "78019": "AB891X", + "78021": "AB891X", + "78022": "AB891X", + "78023": "AB891X", + "78024": "AB891X", + "78025": "AB891X", + "78026": "AB891X", + "78027": "AB891X", + "78028": "AB891X", + "78029": "AB891X", + "78039": "AB891X", + "78040": "AB891X", + "78041": "AB891X", + "78042": "AB891X", + "78043": "AB891X", + "78044": "AB891X", + "78045": "AB891X", + "78046": "AB891X", + "78049": "AB891X", + "78050": "AB891X", + "78052": "AB891X", + "78054": "AB891X", + "78055": "AB891X", + "78056": "AB891X", + "78057": "AB891X", + "78058": "AB891X", + "78059": "AB891X", + "78060": "AB891X", + "78061": "AB891X", + "78062": "AB891X", + "78063": "AB891X", + "78064": "AB891X", + "78065": "AB891X", + "78066": "AB891X", + "78067": "AB891X", + "78069": "AB891X", + "78070": "AB890X", + "78071": "AB891X", + "78072": "AB891X", + "78073": "AB891X", + "78074": "AB891X", + "78075": "AB891X", + "78076": "AB891X", + "78101": "AB891X", + "78102": "AB891X", + "78104": "AB891X", + "78107": "AB889X", + "78108": "AB891X", + "78109": "AB891X", + "78111": "AB891X", + "78112": "AB891X", + "78113": "AB891X", + "78114": "AB891X", + "78115": "AB891X", + "78116": "AB891X", + "78117": "AB891X", + "78118": "AB891X", + "78119": "AB891X", + "78121": "AB891X", + "78122": "AB891X", + "78123": "AB891X", + "78124": "AB891X", + "78125": "AB891X", + "78130": "AB890X", + "78131": "AB890X", + "78132": "AB890X", + "78133": "AB890X", + "78135": "AB890X", + "78140": "AB891X", + "78141": "AB890X", + "78142": "AB891X", + "78143": "AB891X", + "78144": "AB891X", + "78145": "AB891X", + "78146": "AB891X", + "78147": "AB891X", + "78148": "AB891X", + "78150": "AB891X", + "78151": "AB891X", + "78152": "AB891X", + "78154": "AB891X", + "78155": "AB891X", + "78156": "AB891X", + "78159": "AB891X", + "78160": "AB891X", + "78161": "AB891X", + "78162": "AB891X", + "78163": "AB890X", + "78164": "AB890X", + "78201": "AB891X", + "78202": "AB891X", + "78203": "AB891X", + "78204": "AB891X", + "78205": "AB891X", + "78206": "AB891X", + "78207": "AB891X", + "78208": "AB891X", + "78209": "AB891X", + "78210": "AB891X", + "78211": "AB891X", + "78212": "AB891X", + "78213": "AB891X", + "78214": "AB891X", + "78215": "AB891X", + "78216": "AB891X", + "78217": "AB891X", + "78218": "AB891X", + "78219": "AB891X", + "78220": "AB891X", + "78221": "AB891X", + "78222": "AB891X", + "78223": "AB891X", + "78224": "AB891X", + "78225": "AB891X", + "78226": "AB891X", + "78227": "AB891X", + "78228": "AB891X", + "78229": "AB891X", + "78230": "AB891X", + "78231": "AB891X", + "78232": "AB891X", + "78233": "AB891X", + "78234": "AB891X", + "78235": "AB891X", + "78236": "AB891X", + "78237": "AB891X", + "78238": "AB891X", + "78239": "AB891X", + "78240": "AB891X", + "78241": "AB891X", + "78242": "AB891X", + "78243": "AB891X", + "78244": "AB891X", + "78245": "AB891X", + "78246": "AB891X", + "78247": "AB891X", + "78248": "AB891X", + "78249": "AB891X", + "78250": "AB891X", + "78251": "AB891X", + "78252": "AB891X", + "78253": "AB891X", + "78254": "AB891X", + "78255": "AB891X", + "78256": "AB891X", + "78257": "AB891X", + "78258": "AB891X", + "78259": "AB891X", + "78260": "AB891X", + "78261": "AB891X", + "78262": "AB891X", + "78263": "AB891X", + "78264": "AB891X", + "78265": "AB891X", + "78266": "AB890X", + "78268": "AB891X", + "78269": "AB891X", + "78270": "AB891X", + "78275": "AB891X", + "78278": "AB891X", + "78279": "AB891X", + "78280": "AB891X", + "78283": "AB891X", + "78284": "AB891X", + "78285": "AB891X", + "78286": "AB891X", + "78287": "AB891X", + "78288": "AB891X", + "78289": "AB891X", + "78291": "AB891X", + "78292": "AB891X", + "78293": "AB891X", + "78294": "AB891X", + "78295": "AB891X", + "78296": "AB891X", + "78297": "AB891X", + "78298": "AB891X", + "78299": "AB891X", + "78330": "AB891X", + "78332": "AB891X", + "78333": "AB891X", + "78335": "AB891X", + "78336": "AB891X", + "78338": "AB891X", + "78339": "AB891X", + "78340": "AB891X", + "78341": "AB891X", + "78342": "AB891X", + "78343": "AB891X", + "78344": "AB891X", + "78347": "AB891X", + "78349": "AB891X", + "78350": "AB891X", + "78351": "AB891X", + "78352": "AB891X", + "78353": "AB891X", + "78355": "AB891X", + "78357": "AB891X", + "78358": "AB891X", + "78359": "AB891X", + "78360": "AB891X", + "78361": "AB891X", + "78362": "AB891X", + "78363": "AB891X", + "78364": "AB891X", + "78368": "AB891X", + "78369": "AB891X", + "78370": "AB891X", + "78371": "AB891X", + "78372": "AB891X", + "78373": "AB891X", + "78374": "AB891X", + "78375": "AB891X", + "78376": "AB891X", + "78377": "AB891X", + "78379": "AB891X", + "78380": "AB891X", + "78381": "AB891X", + "78382": "AB891X", + "78383": "AB891X", + "78384": "AB891X", + "78385": "AB891X", + "78387": "AB891X", + "78389": "AB891X", + "78390": "AB891X", + "78391": "AB891X", + "78393": "AB891X", + "78401": "AB891X", + "78402": "AB891X", + "78403": "AB891X", + "78404": "AB891X", + "78405": "AB891X", + "78406": "AB891X", + "78407": "AB891X", + "78408": "AB891X", + "78409": "AB891X", + "78410": "AB891X", + "78411": "AB891X", + "78412": "AB891X", + "78413": "AB891X", + "78414": "AB891X", + "78415": "AB891X", + "78416": "AB891X", + "78417": "AB891X", + "78418": "AB891X", + "78419": "AB891X", + "78426": "AB891X", + "78427": "AB891X", + "78460": "AB891X", + "78461": "AB891X", + "78463": "AB891X", + "78465": "AB891X", + "78466": "AB891X", + "78467": "AB891X", + "78468": "AB891X", + "78469": "AB891X", + "78470": "AB891X", + "78471": "AB891X", + "78472": "AB891X", + "78473": "AB891X", + "78474": "AB891X", + "78475": "AB891X", + "78476": "AB891X", + "78477": "AB891X", + "78478": "AB891X", + "78480": "AB891X", + "78501": "AB891X", + "78502": "AB891X", + "78503": "AB891X", + "78504": "AB891X", + "78505": "AB891X", + "78516": "AB891X", + "78520": "AB891X", + "78521": "AB891X", + "78522": "AB891X", + "78523": "AB891X", + "78526": "AB891X", + "78535": "AB891X", + "78536": "AB891X", + "78537": "AB891X", + "78538": "AB891X", + "78539": "AB891X", + "78540": "AB891X", + "78541": "AB891X", + "78542": "AB891X", + "78543": "AB891X", + "78545": "AB891X", + "78547": "AB891X", + "78548": "AB891X", + "78549": "AB891X", + "78550": "AB891X", + "78551": "AB891X", + "78552": "AB891X", + "78553": "AB891X", + "78557": "AB891X", + "78558": "AB891X", + "78559": "AB891X", + "78560": "AB891X", + "78561": "AB891X", + "78562": "AB891X", + "78563": "AB891X", + "78564": "AB891X", + "78565": "AB891X", + "78566": "AB891X", + "78567": "AB891X", + "78568": "AB891X", + "78569": "AB891X", + "78570": "AB891X", + "78572": "AB891X", + "78573": "AB891X", + "78574": "AB891X", + "78575": "AB891X", + "78576": "AB891X", + "78577": "AB891X", + "78578": "AB891X", + "78579": "AB891X", + "78580": "AB891X", + "78582": "AB891X", + "78583": "AB891X", + "78584": "AB891X", + "78585": "AB891X", + "78586": "AB891X", + "78588": "AB891X", + "78589": "AB891X", + "78590": "AB891X", + "78591": "AB891X", + "78592": "AB891X", + "78593": "AB891X", + "78594": "AB891X", + "78595": "AB891X", + "78596": "AB891X", + "78597": "AB891X", + "78598": "AB891X", + "78599": "AB891X", + "78602": "AB890X", + "78604": "AB891X", + "78605": "AB890X", + "78606": "AB890X", + "78607": "AB890X", + "78608": "AB890X", + "78609": "AB890X", + "78610": "AB890X", + "78611": "AB890X", + "78612": "AB890X", + "78613": "AB890X", + "78614": "AB891X", + "78615": "AB890X", + "78616": "AB890X", + "78617": "AB890X", + "78618": "AB890X", + "78619": "AB890X", + "78620": "AB890X", + "78621": "AB890X", + "78622": "AB890X", + "78623": "AB890X", + "78624": "AB890X", + "78626": "AB890X", + "78627": "AB890X", + "78628": "AB890X", + "78629": "AB891X", + "78630": "AB890X", + "78631": "AB890X", + "78632": "AB891X", + "78633": "AB890X", + "78634": "AB890X", + "78635": "AB890X", + "78636": "AB890X", + "78638": "AB891X", + "78639": "AB890X", + "78640": "AB890X", + "78641": "AB890X", + "78642": "AB890X", + "78643": "AB890X", + "78644": "AB890X", + "78645": "AB890X", + "78646": "AB890X", + "78648": "AB890X", + "78650": "AB890X", + "78651": "AB890X", + "78652": "AB890X", + "78653": "AB890X", + "78654": "AB890X", + "78655": "AB890X", + "78656": "AB890X", + "78657": "AB890X", + "78658": "AB891X", + "78659": "AB890X", + "78660": "AB890X", + "78661": "AB890X", + "78662": "AB890X", + "78663": "AB890X", + "78664": "AB890X", + "78665": "AB890X", + "78666": "AB890X", + "78667": "AB890X", + "78669": "AB890X", + "78670": "AB891X", + "78671": "AB890X", + "78672": "AB890X", + "78673": "AB890X", + "78674": "AB890X", + "78675": "AB890X", + "78676": "AB890X", + "78677": "AB891X", + "78680": "AB890X", + "78681": "AB890X", + "78682": "AB890X", + "78683": "AB890X", + "78691": "AB890X", + "78701": "AB890X", + "78702": "AB890X", + "78703": "AB890X", + "78704": "AB890X", + "78705": "AB890X", + "78708": "AB890X", + "78709": "AB890X", + "78710": "AB890X", + "78711": "AB890X", + "78712": "AB890X", + "78713": "AB890X", + "78714": "AB890X", + "78715": "AB890X", + "78716": "AB890X", + "78717": "AB890X", + "78718": "AB890X", + "78719": "AB890X", + "78720": "AB890X", + "78721": "AB890X", + "78722": "AB890X", + "78723": "AB890X", + "78724": "AB890X", + "78725": "AB890X", + "78726": "AB890X", + "78727": "AB890X", + "78728": "AB890X", + "78729": "AB890X", + "78730": "AB890X", + "78731": "AB890X", + "78732": "AB890X", + "78733": "AB890X", + "78734": "AB890X", + "78735": "AB890X", + "78736": "AB890X", + "78737": "AB890X", + "78738": "AB890X", + "78739": "AB890X", + "78741": "AB890X", + "78742": "AB890X", + "78744": "AB890X", + "78745": "AB890X", + "78746": "AB890X", + "78747": "AB890X", + "78748": "AB890X", + "78749": "AB890X", + "78750": "AB890X", + "78751": "AB890X", + "78752": "AB890X", + "78753": "AB890X", + "78754": "AB890X", + "78755": "AB890X", + "78756": "AB890X", + "78757": "AB890X", + "78758": "AB890X", + "78759": "AB890X", + "78760": "AB890X", + "78761": "AB890X", + "78762": "AB890X", + "78763": "AB890X", + "78764": "AB890X", + "78765": "AB890X", + "78766": "AB890X", + "78767": "AB890X", + "78768": "AB890X", + "78769": "AB890X", + "78772": "AB890X", + "78773": "AB890X", + "78774": "AB890X", + "78778": "AB890X", + "78779": "AB890X", + "78780": "AB890X", + "78781": "AB890X", + "78783": "AB890X", + "78785": "AB890X", + "78786": "AB890X", + "78788": "AB890X", + "78789": "AB890X", + "78798": "AB890X", + "78799": "AB890X", + "78801": "AB891X", + "78802": "AB891X", + "78827": "AB891X", + "78828": "AB891X", + "78829": "AB891X", + "78830": "AB891X", + "78832": "AB891X", + "78833": "AB891X", + "78834": "AB891X", + "78836": "AB891X", + "78837": "AB891X", + "78838": "AB891X", + "78839": "AB891X", + "78840": "AB891X", + "78841": "AB891X", + "78842": "AB891X", + "78843": "AB891X", + "78847": "AB891X", + "78850": "AB891X", + "78851": "AB900X", + "78852": "AB891X", + "78853": "AB891X", + "78860": "AB891X", + "78861": "AB891X", + "78870": "AB891X", + "78871": "AB891X", + "78872": "AB891X", + "78873": "AB891X", + "78877": "AB891X", + "78879": "AB891X", + "78880": "AB891X", + "78881": "AB891X", + "78883": "AB891X", + "78884": "AB891X", + "78885": "AB891X", + "78886": "AB891X", + "78931": "AB890X", + "78932": "AB890X", + "78933": "AB890X", + "78934": "AB890X", + "78935": "AB890X", + "78938": "AB890X", + "78940": "AB890X", + "78941": "AB890X", + "78942": "AB890X", + "78943": "AB890X", + "78944": "AB890X", + "78945": "AB890X", + "78946": "AB890X", + "78947": "AB890X", + "78948": "AB890X", + "78949": "AB890X", + "78950": "AB890X", + "78951": "AB890X", + "78952": "AB890X", + "78953": "AB890X", + "78954": "AB890X", + "78956": "AB890X", + "78957": "AB890X", + "78959": "AB891X", + "78960": "AB890X", + "78961": "AB890X", + "78962": "AB890X", + "78963": "AB890X", + "79001": "AB900X", + "79002": "AB900X", + "79003": "AB900X", + "79005": "AB900X", + "79007": "AB900X", + "79008": "AB900X", + "79009": "AB900X", + "79010": "AB900X", + "79011": "AB900X", + "79012": "AB900X", + "79013": "AB900X", + "79014": "AB900X", + "79015": "AB900X", + "79016": "AB900X", + "79018": "AB900X", + "79019": "AB900X", + "79021": "AB900X", + "79022": "AB900X", + "79024": "AB900X", + "79025": "AB900X", + "79027": "AB900X", + "79029": "AB900X", + "79031": "AB900X", + "79032": "AB900X", + "79033": "AB890X", + "79034": "AB900X", + "79035": "AB900X", + "79036": "AB900X", + "79039": "AB900X", + "79040": "AB900X", + "79041": "AB900X", + "79042": "AB900X", + "79043": "AB900X", + "79044": "AB900X", + "79045": "AB900X", + "79046": "AB900X", + "79051": "AB900X", + "79052": "AB900X", + "79053": "AB900X", + "79054": "AB900X", + "79056": "AB900X", + "79057": "AB900X", + "79058": "AB900X", + "79059": "AB900X", + "79061": "AB900X", + "79062": "AB900X", + "79063": "AB900X", + "79064": "AB900X", + "79065": "AB900X", + "79066": "AB900X", + "79068": "AB900X", + "79070": "AB890X", + "79072": "AB900X", + "79073": "AB900X", + "79077": "AB900X", + "79078": "AB900X", + "79079": "AB900X", + "79080": "AB900X", + "79081": "AB900X", + "79082": "AB900X", + "79083": "AB900X", + "79084": "AB900X", + "79085": "AB900X", + "79086": "AB900X", + "79087": "AB900X", + "79088": "AB900X", + "79091": "AB900X", + "79092": "AB900X", + "79093": "AB890X", + "79094": "AB900X", + "79095": "AB900X", + "79096": "AB900X", + "79097": "AB900X", + "79098": "AB900X", + "79101": "AB900X", + "79102": "AB900X", + "79103": "AB900X", + "79104": "AB900X", + "79105": "AB900X", + "79106": "AB900X", + "79107": "AB900X", + "79108": "AB900X", + "79109": "AB900X", + "79110": "AB900X", + "79111": "AB900X", + "79114": "AB900X", + "79116": "AB900X", + "79117": "AB900X", + "79118": "AB900X", + "79119": "AB900X", + "79120": "AB900X", + "79121": "AB900X", + "79124": "AB900X", + "79159": "AB900X", + "79166": "AB900X", + "79168": "AB900X", + "79172": "AB900X", + "79174": "AB900X", + "79178": "AB900X", + "79185": "AB900X", + "79187": "AB900X", + "79189": "AB900X", + "79201": "AB900X", + "79220": "AB889X", + "79221": "AB900X", + "79223": "AB900X", + "79225": "AB900X", + "79226": "AB900X", + "79227": "AB900X", + "79229": "AB889X", + "79230": "AB900X", + "79231": "AB900X", + "79233": "AB900X", + "79234": "AB900X", + "79235": "AB900X", + "79236": "AB900X", + "79237": "AB900X", + "79239": "AB900X", + "79240": "AB900X", + "79241": "AB900X", + "79243": "AB889X", + "79244": "AB900X", + "79245": "AB900X", + "79247": "AB900X", + "79248": "AB900X", + "79250": "AB900X", + "79251": "AB900X", + "79252": "AB900X", + "79255": "AB900X", + "79256": "AB900X", + "79257": "AB900X", + "79258": "AB900X", + "79259": "AB900X", + "79261": "AB900X", + "79311": "AB900X", + "79312": "AB900X", + "79313": "AB900X", + "79314": "AB900X", + "79316": "AB900X", + "79320": "AB900X", + "79322": "AB900X", + "79323": "AB900X", + "79324": "AB900X", + "79325": "AB900X", + "79326": "AB900X", + "79329": "AB900X", + "79330": "AB900X", + "79331": "AB900X", + "79336": "AB900X", + "79338": "AB900X", + "79339": "AB900X", + "79342": "AB900X", + "79343": "AB900X", + "79344": "AB900X", + "79345": "AB900X", + "79346": "AB900X", + "79347": "AB900X", + "79350": "AB900X", + "79351": "AB900X", + "79353": "AB900X", + "79355": "AB900X", + "79356": "AB900X", + "79357": "AB900X", + "79358": "AB900X", + "79359": "AB900X", + "79360": "AB900X", + "79363": "AB900X", + "79364": "AB900X", + "79366": "AB900X", + "79367": "AB900X", + "79369": "AB900X", + "79370": "AB889X", + "79371": "AB900X", + "79372": "AB900X", + "79373": "AB900X", + "79376": "AB900X", + "79377": "AB900X", + "79378": "AB900X", + "79379": "AB900X", + "79380": "AB900X", + "79381": "AB900X", + "79382": "AB900X", + "79383": "AB900X", + "79401": "AB900X", + "79402": "AB900X", + "79403": "AB900X", + "79404": "AB900X", + "79405": "AB900X", + "79406": "AB900X", + "79407": "AB900X", + "79408": "AB900X", + "79409": "AB900X", + "79410": "AB900X", + "79411": "AB900X", + "79412": "AB900X", + "79413": "AB900X", + "79414": "AB900X", + "79415": "AB900X", + "79416": "AB900X", + "79423": "AB900X", + "79424": "AB900X", + "79430": "AB900X", + "79452": "AB900X", + "79453": "AB900X", + "79457": "AB900X", + "79464": "AB900X", + "79490": "AB900X", + "79491": "AB900X", + "79493": "AB900X", + "79499": "AB900X", + "79501": "AB900X", + "79502": "AB900X", + "79503": "AB900X", + "79504": "AB900X", + "79505": "AB900X", + "79506": "AB900X", + "79508": "AB900X", + "79510": "AB900X", + "79511": "AB900X", + "79512": "AB900X", + "79516": "AB900X", + "79517": "AB900X", + "79518": "AB900X", + "79519": "AB900X", + "79520": "AB900X", + "79521": "AB900X", + "79525": "AB900X", + "79526": "AB900X", + "79527": "AB900X", + "79528": "AB900X", + "79529": "AB900X", + "79530": "AB900X", + "79532": "AB900X", + "79533": "AB900X", + "79534": "AB900X", + "79535": "AB900X", + "79536": "AB900X", + "79537": "AB900X", + "79538": "AB900X", + "79539": "AB900X", + "79540": "AB900X", + "79541": "AB900X", + "79543": "AB900X", + "79544": "AB900X", + "79545": "AB900X", + "79546": "AB900X", + "79547": "AB900X", + "79548": "AB900X", + "79549": "AB900X", + "79550": "AB900X", + "79553": "AB900X", + "79556": "AB900X", + "79560": "AB900X", + "79561": "AB900X", + "79562": "AB900X", + "79563": "AB900X", + "79565": "AB900X", + "79566": "AB900X", + "79567": "AB900X", + "79601": "AB900X", + "79602": "AB900X", + "79603": "AB900X", + "79604": "AB900X", + "79605": "AB900X", + "79606": "AB900X", + "79607": "AB900X", + "79608": "AB900X", + "79697": "AB900X", + "79698": "AB900X", + "79699": "AB900X", + "79701": "AB900X", + "79702": "AB900X", + "79703": "AB900X", + "79704": "AB900X", + "79705": "AB900X", + "79706": "AB900X", + "79707": "AB900X", + "79708": "AB900X", + "79710": "AB900X", + "79711": "AB900X", + "79712": "AB900X", + "79713": "AB900X", + "79714": "AB900X", + "79718": "AB900X", + "79719": "AB900X", + "79720": "AB900X", + "79721": "AB900X", + "79730": "AB900X", + "79731": "AB900X", + "79733": "AB900X", + "79734": "AB900X", + "79735": "AB900X", + "79738": "AB900X", + "79739": "AB900X", + "79740": "AB900X", + "79741": "AB900X", + "79742": "AB900X", + "79743": "AB900X", + "79744": "AB900X", + "79745": "AB889X", + "79748": "AB900X", + "79749": "AB900X", + "79752": "AB900X", + "79754": "AB900X", + "79755": "AB900X", + "79756": "AB900X", + "79758": "AB900X", + "79759": "AB900X", + "79760": "AB900X", + "79761": "AB900X", + "79762": "AB900X", + "79763": "AB900X", + "79764": "AB900X", + "79765": "AB900X", + "79766": "AB900X", + "79768": "AB900X", + "79769": "AB900X", + "79770": "AB900X", + "79772": "AB900X", + "79776": "AB900X", + "79777": "AB900X", + "79778": "AB900X", + "79780": "AB900X", + "79781": "AB900X", + "79782": "AB900X", + "79783": "AB900X", + "79785": "AB900X", + "79786": "AB900X", + "79788": "AB900X", + "79789": "AB889X", + "79821": "AB889X", + "79830": "AB900X", + "79831": "AB900X", + "79832": "AB900X", + "79834": "AB900X", + "79835": "AB889X", + "79836": "AB889X", + "79837": "AB889X", + "79838": "AB889X", + "79839": "AB889X", + "79842": "AB900X", + "79843": "AB900X", + "79845": "AB900X", + "79846": "AB900X", + "79847": "AB889X", + "79848": "AB900X", + "79849": "AB889X", + "79851": "AB889X", + "79852": "AB900X", + "79853": "AB889X", + "79854": "AB900X", + "79855": "AB900X", + "79901": "AB889X", + "79902": "AB889X", + "79903": "AB889X", + "79904": "AB889X", + "79905": "AB889X", + "79906": "AB889X", + "79907": "AB889X", + "79908": "AB889X", + "79910": "AB889X", + "79911": "AB889X", + "79912": "AB889X", + "79913": "AB889X", + "79914": "AB889X", + "79915": "AB889X", + "79916": "AB889X", + "79917": "AB889X", + "79918": "AB889X", + "79920": "AB889X", + "79922": "AB889X", + "79923": "AB889X", + "79924": "AB889X", + "79925": "AB889X", + "79926": "AB889X", + "79927": "AB889X", + "79928": "AB889X", + "79929": "AB889X", + "79930": "AB889X", + "79931": "AB889X", + "79932": "AB889X", + "79934": "AB889X", + "79935": "AB889X", + "79936": "AB889X", + "79937": "AB889X", + "79938": "AB889X", + "79940": "AB889X", + "79941": "AB889X", + "79942": "AB889X", + "79943": "AB889X", + "79944": "AB889X", + "79945": "AB889X", + "79946": "AB889X", + "79947": "AB889X", + "79948": "AB889X", + "79949": "AB889X", + "79950": "AB889X", + "79951": "AB889X", + "79952": "AB889X", + "79953": "AB889X", + "79954": "AB889X", + "79955": "AB889X", + "79958": "AB889X", + "79960": "AB889X", + "79961": "AB889X", + "79968": "AB889X", + "79976": "AB889X", + "79978": "AB889X", + "79980": "AB889X", + "79990": "AB889X", + "79995": "AB889X", + "79996": "AB889X", + "79997": "AB889X", + "79998": "AB889X", + "79999": "AB889X", + "80001": "AB887X", + "80002": "AB887X", + "80003": "AB887X", + "80004": "AB887X", + "80005": "AB887X", + "80006": "AB887X", + "80007": "AB887X", + "80010": "AB887X", + "80011": "AB887X", + "80012": "AB887X", + "80013": "AB887X", + "80014": "AB887X", + "80015": "AB887X", + "80016": "AB887X", + "80017": "AB887X", + "80018": "AB887X", + "80019": "AB887X", + "80020": "AB887X", + "80021": "AB887X", + "80022": "AB887X", + "80023": "AB887X", + "80024": "AB887X", + "80025": "AB887X", + "80026": "AB887X", + "80027": "AB887X", + "80028": "AB887X", + "80030": "AB887X", + "80031": "AB887X", + "80033": "AB887X", + "80034": "AB887X", + "80035": "AB887X", + "80036": "AB887X", + "80037": "AB887X", + "80038": "AB887X", + "80040": "AB887X", + "80041": "AB887X", + "80042": "AB887X", + "80044": "AB887X", + "80045": "AB887X", + "80046": "AB887X", + "80047": "AB887X", + "80101": "AB887X", + "80102": "AB887X", + "80103": "AB887X", + "80104": "AB887X", + "80105": "AB887X", + "80106": "AB887X", + "80107": "AB887X", + "80108": "AB887X", + "80109": "AB887X", + "80110": "AB887X", + "80111": "AB887X", + "80112": "AB887X", + "80113": "AB887X", + "80116": "AB887X", + "80117": "AB887X", + "80118": "AB887X", + "80120": "AB887X", + "80121": "AB887X", + "80122": "AB887X", + "80123": "AB887X", + "80124": "AB887X", + "80125": "AB887X", + "80126": "AB887X", + "80127": "AB887X", + "80128": "AB887X", + "80129": "AB887X", + "80130": "AB887X", + "80131": "AB887X", + "80132": "AB887X", + "80133": "AB887X", + "80134": "AB887X", + "80135": "AB887X", + "80136": "AB887X", + "80137": "AB887X", + "80138": "AB887X", + "80150": "AB887X", + "80151": "AB887X", + "80155": "AB887X", + "80160": "AB887X", + "80161": "AB887X", + "80162": "AB887X", + "80163": "AB887X", + "80165": "AB887X", + "80166": "AB887X", + "80201": "AB887X", + "80202": "AB887X", + "80203": "AB887X", + "80204": "AB887X", + "80205": "AB887X", + "80206": "AB887X", + "80207": "AB887X", + "80208": "AB887X", + "80209": "AB887X", + "80210": "AB887X", + "80211": "AB887X", + "80212": "AB887X", + "80214": "AB887X", + "80215": "AB887X", + "80216": "AB887X", + "80217": "AB887X", + "80218": "AB887X", + "80219": "AB887X", + "80220": "AB887X", + "80221": "AB887X", + "80222": "AB887X", + "80223": "AB887X", + "80224": "AB887X", + "80225": "AB887X", + "80226": "AB887X", + "80227": "AB887X", + "80228": "AB887X", + "80229": "AB887X", + "80230": "AB887X", + "80231": "AB887X", + "80232": "AB887X", + "80233": "AB887X", + "80234": "AB887X", + "80235": "AB887X", + "80236": "AB887X", + "80237": "AB887X", + "80238": "AB887X", + "80239": "AB887X", + "80241": "AB887X", + "80243": "AB887X", + "80244": "AB887X", + "80246": "AB887X", + "80247": "AB887X", + "80248": "AB887X", + "80249": "AB887X", + "80250": "AB887X", + "80251": "AB887X", + "80252": "AB887X", + "80256": "AB887X", + "80257": "AB887X", + "80259": "AB887X", + "80260": "AB887X", + "80261": "AB887X", + "80262": "AB887X", + "80263": "AB887X", + "80264": "AB887X", + "80265": "AB887X", + "80266": "AB887X", + "80271": "AB887X", + "80273": "AB887X", + "80274": "AB887X", + "80279": "AB887X", + "80280": "AB887X", + "80281": "AB887X", + "80290": "AB887X", + "80291": "AB887X", + "80293": "AB887X", + "80294": "AB887X", + "80295": "AB887X", + "80299": "AB887X", + "80301": "AB887X", + "80302": "AB887X", + "80303": "AB887X", + "80304": "AB887X", + "80305": "AB887X", + "80306": "AB887X", + "80307": "AB887X", + "80308": "AB887X", + "80309": "AB887X", + "80310": "AB887X", + "80314": "AB887X", + "80321": "AB887X", + "80322": "AB887X", + "80323": "AB887X", + "80328": "AB887X", + "80329": "AB887X", + "80401": "AB887X", + "80402": "AB887X", + "80403": "AB887X", + "80419": "AB887X", + "80420": "AB887X", + "80421": "AB887X", + "80422": "AB887X", + "80423": "AB887X", + "80424": "AB887X", + "80425": "AB887X", + "80426": "AB887X", + "80427": "AB887X", + "80428": "AB887X", + "80429": "AB887X", + "80430": "AB887X", + "80432": "AB887X", + "80433": "AB887X", + "80434": "AB887X", + "80435": "AB887X", + "80436": "AB887X", + "80437": "AB887X", + "80438": "AB887X", + "80439": "AB887X", + "80440": "AB887X", + "80442": "AB887X", + "80443": "AB887X", + "80444": "AB887X", + "80446": "AB887X", + "80447": "AB887X", + "80448": "AB887X", + "80449": "AB887X", + "80451": "AB887X", + "80452": "AB887X", + "80453": "AB887X", + "80454": "AB887X", + "80455": "AB887X", + "80456": "AB887X", + "80457": "AB887X", + "80459": "AB887X", + "80461": "AB887X", + "80463": "AB887X", + "80465": "AB887X", + "80466": "AB887X", + "80467": "AB887X", + "80468": "AB887X", + "80469": "AB887X", + "80470": "AB887X", + "80471": "AB887X", + "80473": "AB887X", + "80474": "AB887X", + "80475": "AB887X", + "80476": "AB887X", + "80477": "AB887X", + "80478": "AB887X", + "80479": "AB887X", + "80480": "AB887X", + "80481": "AB887X", + "80482": "AB887X", + "80483": "AB887X", + "80487": "AB887X", + "80488": "AB887X", + "80497": "AB887X", + "80498": "AB887X", + "80501": "AB887X", + "80502": "AB887X", + "80503": "AB887X", + "80504": "AB887X", + "80510": "AB887X", + "80511": "AB887X", + "80512": "AB887X", + "80513": "AB887X", + "80514": "AB887X", + "80515": "AB887X", + "80516": "AB887X", + "80517": "AB887X", + "80520": "AB887X", + "80521": "AB887X", + "80522": "AB887X", + "80523": "AB887X", + "80524": "AB887X", + "80525": "AB887X", + "80526": "AB887X", + "80527": "AB887X", + "80528": "AB887X", + "80530": "AB887X", + "80532": "AB887X", + "80533": "AB887X", + "80534": "AB887X", + "80535": "AB887X", + "80536": "AB887X", + "80537": "AB887X", + "80538": "AB887X", + "80539": "AB887X", + "80540": "AB887X", + "80541": "AB887X", + "80542": "AB887X", + "80543": "AB887X", + "80544": "AB887X", + "80545": "AB887X", + "80546": "AB887X", + "80547": "AB887X", + "80549": "AB887X", + "80550": "AB887X", + "80551": "AB887X", + "80553": "AB887X", + "80601": "AB887X", + "80602": "AB887X", + "80603": "AB887X", + "80610": "AB887X", + "80611": "AB887X", + "80612": "AB887X", + "80614": "AB887X", + "80615": "AB887X", + "80620": "AB887X", + "80621": "AB887X", + "80622": "AB887X", + "80623": "AB887X", + "80624": "AB887X", + "80631": "AB887X", + "80632": "AB887X", + "80633": "AB887X", + "80634": "AB887X", + "80638": "AB887X", + "80639": "AB887X", + "80640": "AB887X", + "80642": "AB887X", + "80643": "AB887X", + "80644": "AB887X", + "80645": "AB887X", + "80646": "AB887X", + "80648": "AB887X", + "80649": "AB887X", + "80650": "AB887X", + "80651": "AB887X", + "80652": "AB887X", + "80653": "AB887X", + "80654": "AB887X", + "80701": "AB887X", + "80705": "AB887X", + "80720": "AB887X", + "80721": "AB887X", + "80722": "AB887X", + "80723": "AB887X", + "80725": "AB887X", + "80726": "AB887X", + "80727": "AB887X", + "80728": "AB887X", + "80729": "AB887X", + "80731": "AB887X", + "80732": "AB887X", + "80733": "AB887X", + "80734": "AB887X", + "80735": "AB887X", + "80736": "AB887X", + "80737": "AB887X", + "80740": "AB887X", + "80741": "AB887X", + "80742": "AB887X", + "80743": "AB887X", + "80744": "AB887X", + "80745": "AB887X", + "80746": "AB887X", + "80747": "AB887X", + "80749": "AB887X", + "80750": "AB887X", + "80751": "AB887X", + "80754": "AB887X", + "80755": "AB887X", + "80757": "AB887X", + "80758": "AB887X", + "80759": "AB887X", + "80801": "AB887X", + "80802": "AB887X", + "80804": "AB887X", + "80805": "AB887X", + "80807": "AB887X", + "80808": "AB887X", + "80809": "AB887X", + "80810": "AB887X", + "80812": "AB887X", + "80813": "AB887X", + "80814": "AB887X", + "80815": "AB887X", + "80816": "AB887X", + "80817": "AB887X", + "80818": "AB887X", + "80819": "AB887X", + "80820": "AB887X", + "80821": "AB887X", + "80822": "AB887X", + "80823": "AB887X", + "80824": "AB887X", + "80825": "AB887X", + "80826": "AB887X", + "80827": "AB887X", + "80828": "AB887X", + "80829": "AB887X", + "80830": "AB887X", + "80831": "AB887X", + "80832": "AB887X", + "80833": "AB887X", + "80834": "AB887X", + "80835": "AB887X", + "80836": "AB887X", + "80840": "AB887X", + "80841": "AB887X", + "80860": "AB887X", + "80861": "AB887X", + "80862": "AB887X", + "80863": "AB887X", + "80864": "AB887X", + "80866": "AB887X", + "80901": "AB887X", + "80903": "AB887X", + "80904": "AB887X", + "80905": "AB887X", + "80906": "AB887X", + "80907": "AB887X", + "80908": "AB887X", + "80909": "AB887X", + "80910": "AB887X", + "80911": "AB887X", + "80912": "AB887X", + "80913": "AB887X", + "80914": "AB887X", + "80915": "AB887X", + "80916": "AB887X", + "80917": "AB887X", + "80918": "AB887X", + "80919": "AB887X", + "80920": "AB887X", + "80921": "AB887X", + "80922": "AB887X", + "80923": "AB887X", + "80924": "AB887X", + "80925": "AB887X", + "80926": "AB887X", + "80927": "AB887X", + "80928": "AB887X", + "80929": "AB887X", + "80930": "AB887X", + "80931": "AB887X", + "80932": "AB887X", + "80933": "AB887X", + "80934": "AB887X", + "80935": "AB887X", + "80936": "AB887X", + "80937": "AB887X", + "80938": "AB887X", + "80939": "AB887X", + "80940": "AB887X", + "80941": "AB887X", + "80942": "AB887X", + "80943": "AB887X", + "80944": "AB887X", + "80945": "AB887X", + "80946": "AB887X", + "80947": "AB887X", + "80949": "AB887X", + "80950": "AB887X", + "80951": "AB887X", + "80960": "AB887X", + "80962": "AB887X", + "80970": "AB887X", + "80977": "AB887X", + "80995": "AB887X", + "80997": "AB887X", + "81001": "AB887X", + "81002": "AB887X", + "81003": "AB887X", + "81004": "AB887X", + "81005": "AB887X", + "81006": "AB887X", + "81007": "AB887X", + "81008": "AB887X", + "81009": "AB887X", + "81010": "AB887X", + "81011": "AB887X", + "81012": "AB887X", + "81019": "AB887X", + "81020": "AB887X", + "81021": "AB887X", + "81022": "AB887X", + "81023": "AB887X", + "81024": "AB887X", + "81025": "AB887X", + "81027": "AB887X", + "81029": "AB887X", + "81030": "AB887X", + "81031": "AB887X", + "81033": "AB887X", + "81034": "AB887X", + "81036": "AB887X", + "81038": "AB887X", + "81039": "AB887X", + "81040": "AB887X", + "81041": "AB887X", + "81043": "AB887X", + "81044": "AB887X", + "81045": "AB887X", + "81046": "AB887X", + "81047": "AB887X", + "81049": "AB887X", + "81050": "AB887X", + "81052": "AB887X", + "81054": "AB887X", + "81055": "AB887X", + "81057": "AB887X", + "81058": "AB887X", + "81059": "AB887X", + "81062": "AB887X", + "81063": "AB887X", + "81064": "AB887X", + "81067": "AB887X", + "81069": "AB887X", + "81071": "AB887X", + "81073": "AB887X", + "81076": "AB887X", + "81077": "AB887X", + "81081": "AB887X", + "81082": "AB887X", + "81084": "AB887X", + "81087": "AB887X", + "81089": "AB887X", + "81090": "AB887X", + "81091": "AB887X", + "81092": "AB887X", + "81101": "AB887X", + "81102": "AB887X", + "81120": "AB887X", + "81121": "AB887X", + "81122": "AB889X", + "81123": "AB887X", + "81124": "AB887X", + "81125": "AB887X", + "81126": "AB887X", + "81127": "AB887X", + "81128": "AB887X", + "81129": "AB887X", + "81130": "AB887X", + "81131": "AB887X", + "81132": "AB887X", + "81133": "AB887X", + "81134": "AB887X", + "81135": "AB887X", + "81136": "AB887X", + "81137": "AB889X", + "81138": "AB887X", + "81140": "AB887X", + "81141": "AB887X", + "81143": "AB887X", + "81144": "AB887X", + "81146": "AB887X", + "81147": "AB887X", + "81148": "AB887X", + "81149": "AB887X", + "81151": "AB887X", + "81152": "AB887X", + "81153": "AB887X", + "81154": "AB887X", + "81155": "AB887X", + "81157": "AB887X", + "81201": "AB887X", + "81210": "AB887X", + "81211": "AB887X", + "81212": "AB887X", + "81215": "AB887X", + "81220": "AB887X", + "81221": "AB887X", + "81222": "AB887X", + "81223": "AB887X", + "81224": "AB887X", + "81225": "AB887X", + "81226": "AB887X", + "81227": "AB887X", + "81228": "AB887X", + "81230": "AB887X", + "81231": "AB887X", + "81232": "AB887X", + "81233": "AB887X", + "81235": "AB887X", + "81236": "AB887X", + "81237": "AB887X", + "81239": "AB887X", + "81240": "AB887X", + "81241": "AB887X", + "81242": "AB887X", + "81243": "AB887X", + "81244": "AB887X", + "81247": "AB887X", + "81248": "AB887X", + "81251": "AB887X", + "81252": "AB887X", + "81253": "AB887X", + "81290": "AB887X", + "81301": "AB889X", + "81302": "AB889X", + "81303": "AB889X", + "81320": "AB889X", + "81321": "AB889X", + "81323": "AB889X", + "81324": "AB889X", + "81325": "AB887X", + "81326": "AB889X", + "81327": "AB889X", + "81328": "AB889X", + "81329": "AB889X", + "81330": "AB889X", + "81331": "AB889X", + "81332": "AB889X", + "81334": "AB889X", + "81335": "AB889X", + "81345": "AB887X", + "81401": "AB887X", + "81402": "AB887X", + "81410": "AB887X", + "81411": "AB887X", + "81413": "AB887X", + "81414": "AB887X", + "81415": "AB887X", + "81416": "AB887X", + "81418": "AB887X", + "81419": "AB887X", + "81420": "AB887X", + "81422": "AB887X", + "81423": "AB887X", + "81424": "AB887X", + "81425": "AB887X", + "81426": "AB887X", + "81427": "AB887X", + "81428": "AB887X", + "81429": "AB887X", + "81430": "AB887X", + "81431": "AB887X", + "81432": "AB887X", + "81433": "AB887X", + "81434": "AB887X", + "81435": "AB887X", + "81501": "AB887X", + "81502": "AB887X", + "81503": "AB887X", + "81504": "AB887X", + "81505": "AB887X", + "81506": "AB887X", + "81507": "AB887X", + "81520": "AB887X", + "81521": "AB887X", + "81522": "AB887X", + "81523": "AB887X", + "81524": "AB887X", + "81525": "AB887X", + "81526": "AB887X", + "81527": "AB887X", + "81601": "AB887X", + "81602": "AB887X", + "81610": "AB892X", + "81611": "AB887X", + "81612": "AB887X", + "81615": "AB887X", + "81620": "AB887X", + "81621": "AB887X", + "81623": "AB887X", + "81624": "AB887X", + "81625": "AB887X", + "81626": "AB887X", + "81630": "AB887X", + "81631": "AB887X", + "81632": "AB887X", + "81633": "AB887X", + "81635": "AB887X", + "81636": "AB887X", + "81637": "AB887X", + "81638": "AB887X", + "81639": "AB887X", + "81640": "AB887X", + "81641": "AB887X", + "81642": "AB887X", + "81643": "AB887X", + "81645": "AB887X", + "81646": "AB887X", + "81647": "AB887X", + "81648": "AB887X", + "81649": "AB887X", + "81650": "AB887X", + "81652": "AB887X", + "81653": "AB887X", + "81654": "AB887X", + "81655": "AB887X", + "81656": "AB887X", + "81657": "AB887X", + "81658": "AB887X", + "82001": "AB887X", + "82002": "AB887X", + "82003": "AB887X", + "82005": "AB887X", + "82006": "AB887X", + "82007": "AB887X", + "82008": "AB887X", + "82009": "AB887X", + "82010": "AB887X", + "82050": "AB887X", + "82051": "AB887X", + "82052": "AB887X", + "82053": "AB887X", + "82054": "AB887X", + "82055": "AB887X", + "82058": "AB887X", + "82059": "AB887X", + "82060": "AB887X", + "82061": "AB887X", + "82063": "AB887X", + "82070": "AB887X", + "82071": "AB887X", + "82072": "AB887X", + "82073": "AB887X", + "82081": "AB887X", + "82082": "AB887X", + "82083": "AB887X", + "82084": "AB887X", + "82190": "AB887X", + "82201": "AB887X", + "82210": "AB887X", + "82212": "AB887X", + "82213": "AB887X", + "82214": "AB887X", + "82215": "AB887X", + "82217": "AB887X", + "82218": "AB887X", + "82219": "AB887X", + "82221": "AB887X", + "82222": "AB887X", + "82223": "AB887X", + "82224": "AB887X", + "82225": "AB887X", + "82227": "AB887X", + "82229": "AB887X", + "82240": "AB887X", + "82242": "AB887X", + "82243": "AB887X", + "82244": "AB887X", + "82301": "AB887X", + "82310": "AB887X", + "82321": "AB887X", + "82322": "AB887X", + "82323": "AB887X", + "82324": "AB887X", + "82325": "AB887X", + "82327": "AB887X", + "82329": "AB887X", + "82331": "AB887X", + "82332": "AB887X", + "82334": "AB887X", + "82335": "AB887X", + "82336": "AB887X", + "82401": "AB887X", + "82410": "AB887X", + "82411": "AB887X", + "82412": "AB887X", + "82414": "AB887X", + "82420": "AB887X", + "82421": "AB887X", + "82422": "AB887X", + "82423": "AB887X", + "82426": "AB887X", + "82428": "AB887X", + "82430": "AB887X", + "82431": "AB887X", + "82432": "AB887X", + "82433": "AB887X", + "82434": "AB887X", + "82435": "AB887X", + "82440": "AB887X", + "82441": "AB887X", + "82442": "AB887X", + "82443": "AB887X", + "82450": "AB887X", + "82501": "AB887X", + "82510": "AB887X", + "82512": "AB887X", + "82513": "AB887X", + "82514": "AB887X", + "82515": "AB887X", + "82516": "AB887X", + "82520": "AB887X", + "82523": "AB887X", + "82524": "AB887X", + "82601": "AB887X", + "82602": "AB887X", + "82604": "AB887X", + "82605": "AB887X", + "82609": "AB887X", + "82615": "AB887X", + "82620": "AB887X", + "82630": "AB887X", + "82633": "AB887X", + "82635": "AB887X", + "82636": "AB887X", + "82637": "AB887X", + "82638": "AB887X", + "82639": "AB887X", + "82640": "AB887X", + "82642": "AB887X", + "82643": "AB887X", + "82644": "AB887X", + "82646": "AB887X", + "82648": "AB887X", + "82649": "AB887X", + "82701": "AB887X", + "82710": "AB887X", + "82711": "AB887X", + "82712": "AB887X", + "82714": "AB887X", + "82715": "AB887X", + "82716": "AB887X", + "82717": "AB887X", + "82718": "AB887X", + "82720": "AB887X", + "82721": "AB887X", + "82723": "AB887X", + "82725": "AB887X", + "82727": "AB887X", + "82729": "AB887X", + "82730": "AB887X", + "82731": "AB887X", + "82732": "AB887X", + "82801": "AB887X", + "82831": "AB887X", + "82832": "AB887X", + "82833": "AB887X", + "82834": "AB887X", + "82835": "AB887X", + "82836": "AB887X", + "82837": "AB887X", + "82838": "AB887X", + "82839": "AB887X", + "82840": "AB887X", + "82842": "AB887X", + "82844": "AB887X", + "82845": "AB887X", + "82901": "AB887X", + "82902": "AB887X", + "82922": "AB892X", + "82923": "AB892X", + "82925": "AB892X", + "82929": "AB887X", + "82930": "AB892X", + "82931": "AB892X", + "82932": "AB887X", + "82933": "AB892X", + "82934": "AB887X", + "82935": "AB887X", + "82936": "AB892X", + "82937": "AB892X", + "82938": "AB887X", + "82939": "AB892X", + "82941": "AB892X", + "82942": "AB887X", + "82943": "AB887X", + "82944": "AB892X", + "82945": "AB887X", + "83001": "AB892X", + "83002": "AB892X", + "83011": "AB892X", + "83012": "AB892X", + "83013": "AB892X", + "83014": "AB892X", + "83025": "AB892X", + "83101": "AB892X", + "83110": "AB892X", + "83111": "AB892X", + "83112": "AB892X", + "83113": "AB892X", + "83114": "AB892X", + "83115": "AB892X", + "83116": "AB892X", + "83118": "AB892X", + "83119": "AB892X", + "83120": "AB892X", + "83121": "AB892X", + "83122": "AB892X", + "83123": "AB892X", + "83124": "AB892X", + "83126": "AB892X", + "83127": "AB892X", + "83128": "AB892X", + "83201": "AB892X", + "83202": "AB892X", + "83203": "AB892X", + "83204": "AB892X", + "83205": "AB892X", + "83206": "AB892X", + "83209": "AB892X", + "83210": "AB892X", + "83211": "AB892X", + "83212": "AB892X", + "83213": "AB892X", + "83214": "AB892X", + "83215": "AB892X", + "83217": "AB892X", + "83218": "AB892X", + "83220": "AB892X", + "83221": "AB892X", + "83223": "AB892X", + "83226": "AB892X", + "83227": "AB892X", + "83228": "AB892X", + "83229": "AB892X", + "83230": "AB892X", + "83232": "AB892X", + "83233": "AB892X", + "83234": "AB892X", + "83235": "AB892X", + "83236": "AB892X", + "83237": "AB892X", + "83238": "AB892X", + "83239": "AB892X", + "83241": "AB892X", + "83243": "AB892X", + "83244": "AB892X", + "83245": "AB892X", + "83246": "AB892X", + "83250": "AB892X", + "83251": "AB892X", + "83252": "AB892X", + "83253": "AB892X", + "83254": "AB892X", + "83255": "AB892X", + "83256": "AB892X", + "83261": "AB892X", + "83262": "AB892X", + "83263": "AB892X", + "83271": "AB892X", + "83272": "AB892X", + "83274": "AB892X", + "83276": "AB892X", + "83277": "AB892X", + "83278": "AB892X", + "83281": "AB892X", + "83283": "AB892X", + "83285": "AB892X", + "83286": "AB892X", + "83287": "AB892X", + "83301": "AB892X", + "83302": "AB892X", + "83303": "AB892X", + "83311": "AB892X", + "83312": "AB892X", + "83313": "AB892X", + "83314": "AB892X", + "83316": "AB892X", + "83318": "AB892X", + "83320": "AB892X", + "83321": "AB892X", + "83322": "AB892X", + "83323": "AB892X", + "83324": "AB892X", + "83325": "AB892X", + "83327": "AB892X", + "83328": "AB892X", + "83330": "AB892X", + "83332": "AB892X", + "83333": "AB892X", + "83334": "AB892X", + "83335": "AB892X", + "83336": "AB892X", + "83337": "AB892X", + "83338": "AB892X", + "83340": "AB892X", + "83341": "AB892X", + "83342": "AB892X", + "83343": "AB892X", + "83344": "AB892X", + "83346": "AB892X", + "83347": "AB892X", + "83348": "AB892X", + "83349": "AB892X", + "83350": "AB892X", + "83352": "AB892X", + "83353": "AB892X", + "83354": "AB892X", + "83355": "AB892X", + "83401": "AB892X", + "83402": "AB892X", + "83403": "AB892X", + "83404": "AB892X", + "83405": "AB892X", + "83406": "AB892X", + "83414": "AB892X", + "83415": "AB892X", + "83420": "AB892X", + "83421": "AB892X", + "83422": "AB892X", + "83423": "AB892X", + "83424": "AB892X", + "83425": "AB892X", + "83427": "AB892X", + "83428": "AB892X", + "83429": "AB892X", + "83431": "AB892X", + "83433": "AB892X", + "83434": "AB892X", + "83435": "AB892X", + "83436": "AB892X", + "83438": "AB892X", + "83440": "AB892X", + "83441": "AB892X", + "83442": "AB892X", + "83443": "AB892X", + "83444": "AB892X", + "83445": "AB892X", + "83446": "AB892X", + "83448": "AB892X", + "83449": "AB892X", + "83450": "AB892X", + "83451": "AB892X", + "83452": "AB892X", + "83454": "AB892X", + "83455": "AB892X", + "83460": "AB892X", + "83462": "AB892X", + "83463": "AB892X", + "83464": "AB892X", + "83465": "AB892X", + "83466": "AB892X", + "83467": "AB892X", + "83468": "AB892X", + "83469": "AB892X", + "83501": "AB890X", + "83520": "AB890X", + "83522": "AB892X", + "83523": "AB892X", + "83524": "AB890X", + "83525": "AB892X", + "83526": "AB892X", + "83530": "AB892X", + "83531": "AB892X", + "83533": "AB892X", + "83535": "AB890X", + "83536": "AB892X", + "83537": "AB890X", + "83539": "AB892X", + "83540": "AB890X", + "83541": "AB890X", + "83542": "AB892X", + "83543": "AB892X", + "83544": "AB890X", + "83545": "AB890X", + "83546": "AB890X", + "83547": "AB892X", + "83548": "AB892X", + "83549": "AB892X", + "83552": "AB892X", + "83553": "AB890X", + "83554": "AB892X", + "83555": "AB892X", + "83601": "AB892X", + "83602": "AB892X", + "83604": "AB892X", + "83605": "AB892X", + "83606": "AB892X", + "83607": "AB892X", + "83610": "AB892X", + "83611": "AB892X", + "83612": "AB892X", + "83615": "AB892X", + "83616": "AB892X", + "83617": "AB892X", + "83619": "AB892X", + "83622": "AB892X", + "83623": "AB892X", + "83624": "AB892X", + "83626": "AB892X", + "83627": "AB892X", + "83628": "AB892X", + "83629": "AB892X", + "83630": "AB892X", + "83631": "AB892X", + "83632": "AB892X", + "83633": "AB892X", + "83634": "AB892X", + "83635": "AB892X", + "83636": "AB892X", + "83637": "AB892X", + "83638": "AB892X", + "83639": "AB892X", + "83641": "AB892X", + "83642": "AB892X", + "83643": "AB892X", + "83644": "AB892X", + "83645": "AB892X", + "83646": "AB892X", + "83647": "AB892X", + "83648": "AB892X", + "83650": "AB892X", + "83651": "AB892X", + "83652": "AB892X", + "83653": "AB892X", + "83654": "AB892X", + "83655": "AB892X", + "83656": "AB892X", + "83657": "AB892X", + "83660": "AB892X", + "83661": "AB892X", + "83666": "AB892X", + "83669": "AB892X", + "83670": "AB892X", + "83671": "AB892X", + "83672": "AB892X", + "83676": "AB892X", + "83677": "AB892X", + "83680": "AB892X", + "83686": "AB892X", + "83687": "AB892X", + "83701": "AB892X", + "83702": "AB892X", + "83703": "AB892X", + "83704": "AB892X", + "83705": "AB892X", + "83706": "AB892X", + "83707": "AB892X", + "83708": "AB892X", + "83709": "AB892X", + "83711": "AB892X", + "83712": "AB892X", + "83713": "AB892X", + "83714": "AB892X", + "83715": "AB892X", + "83716": "AB892X", + "83717": "AB892X", + "83719": "AB892X", + "83720": "AB892X", + "83721": "AB892X", + "83722": "AB892X", + "83724": "AB892X", + "83725": "AB892X", + "83726": "AB892X", + "83727": "AB892X", + "83728": "AB892X", + "83729": "AB892X", + "83730": "AB892X", + "83731": "AB892X", + "83732": "AB892X", + "83733": "AB892X", + "83735": "AB892X", + "83756": "AB892X", + "83757": "AB892X", + "83799": "AB892X", + "83801": "AB890X", + "83802": "AB890X", + "83803": "AB890X", + "83804": "AB890X", + "83805": "AB890X", + "83806": "AB890X", + "83808": "AB890X", + "83809": "AB890X", + "83810": "AB890X", + "83811": "AB890X", + "83812": "AB890X", + "83813": "AB890X", + "83814": "AB890X", + "83815": "AB890X", + "83816": "AB890X", + "83821": "AB890X", + "83822": "AB890X", + "83823": "AB890X", + "83824": "AB890X", + "83825": "AB890X", + "83826": "AB890X", + "83827": "AB890X", + "83830": "AB890X", + "83832": "AB890X", + "83833": "AB890X", + "83834": "AB890X", + "83835": "AB890X", + "83836": "AB890X", + "83837": "AB890X", + "83839": "AB890X", + "83840": "AB890X", + "83841": "AB890X", + "83842": "AB890X", + "83843": "AB890X", + "83844": "AB890X", + "83845": "AB890X", + "83846": "AB890X", + "83847": "AB890X", + "83848": "AB890X", + "83849": "AB890X", + "83850": "AB890X", + "83851": "AB890X", + "83852": "AB890X", + "83853": "AB890X", + "83854": "AB890X", + "83855": "AB890X", + "83856": "AB890X", + "83857": "AB890X", + "83858": "AB890X", + "83860": "AB890X", + "83861": "AB890X", + "83864": "AB890X", + "83865": "AB890X", + "83866": "AB890X", + "83867": "AB890X", + "83868": "AB890X", + "83869": "AB890X", + "83870": "AB890X", + "83871": "AB890X", + "83872": "AB890X", + "83873": "AB890X", + "83874": "AB890X", + "83876": "AB890X", + "83877": "AB890X", + "84001": "AB892X", + "84002": "AB892X", + "84003": "AB892X", + "84004": "AB892X", + "84005": "AB892X", + "84006": "AB892X", + "84007": "AB892X", + "84008": "AB892X", + "84010": "AB892X", + "84011": "AB892X", + "84013": "AB892X", + "84014": "AB892X", + "84015": "AB892X", + "84016": "AB892X", + "84017": "AB892X", + "84018": "AB892X", + "84020": "AB892X", + "84021": "AB892X", + "84022": "AB892X", + "84023": "AB892X", + "84024": "AB892X", + "84025": "AB892X", + "84026": "AB892X", + "84027": "AB892X", + "84028": "AB892X", + "84029": "AB892X", + "84031": "AB892X", + "84032": "AB892X", + "84033": "AB892X", + "84034": "AB892X", + "84035": "AB892X", + "84036": "AB892X", + "84037": "AB892X", + "84038": "AB892X", + "84039": "AB892X", + "84040": "AB892X", + "84041": "AB892X", + "84042": "AB892X", + "84043": "AB892X", + "84044": "AB892X", + "84045": "AB892X", + "84046": "AB892X", + "84047": "AB892X", + "84049": "AB892X", + "84050": "AB892X", + "84051": "AB892X", + "84052": "AB892X", + "84053": "AB892X", + "84054": "AB892X", + "84055": "AB892X", + "84056": "AB892X", + "84057": "AB892X", + "84058": "AB892X", + "84059": "AB892X", + "84060": "AB892X", + "84061": "AB892X", + "84062": "AB892X", + "84063": "AB892X", + "84064": "AB892X", + "84065": "AB892X", + "84066": "AB892X", + "84067": "AB892X", + "84068": "AB892X", + "84069": "AB892X", + "84070": "AB892X", + "84071": "AB892X", + "84072": "AB892X", + "84073": "AB892X", + "84074": "AB892X", + "84075": "AB892X", + "84076": "AB892X", + "84078": "AB892X", + "84079": "AB892X", + "84080": "AB892X", + "84081": "AB892X", + "84082": "AB892X", + "84083": "AB892X", + "84084": "AB892X", + "84085": "AB892X", + "84086": "AB892X", + "84087": "AB892X", + "84088": "AB892X", + "84089": "AB892X", + "84090": "AB892X", + "84091": "AB892X", + "84092": "AB892X", + "84093": "AB892X", + "84094": "AB892X", + "84095": "AB892X", + "84096": "AB892X", + "84097": "AB892X", + "84098": "AB892X", + "84101": "AB892X", + "84102": "AB892X", + "84103": "AB892X", + "84104": "AB892X", + "84105": "AB892X", + "84106": "AB892X", + "84107": "AB892X", + "84108": "AB892X", + "84109": "AB892X", + "84110": "AB892X", + "84111": "AB892X", + "84112": "AB892X", + "84113": "AB892X", + "84114": "AB892X", + "84115": "AB892X", + "84116": "AB892X", + "84117": "AB892X", + "84118": "AB892X", + "84119": "AB892X", + "84120": "AB892X", + "84121": "AB892X", + "84122": "AB892X", + "84123": "AB892X", + "84124": "AB892X", + "84125": "AB892X", + "84126": "AB892X", + "84127": "AB892X", + "84128": "AB892X", + "84130": "AB892X", + "84131": "AB892X", + "84132": "AB892X", + "84133": "AB892X", + "84134": "AB892X", + "84136": "AB892X", + "84138": "AB892X", + "84139": "AB892X", + "84141": "AB892X", + "84143": "AB892X", + "84144": "AB892X", + "84145": "AB892X", + "84147": "AB892X", + "84148": "AB892X", + "84150": "AB892X", + "84151": "AB892X", + "84152": "AB892X", + "84157": "AB892X", + "84158": "AB892X", + "84165": "AB892X", + "84170": "AB892X", + "84171": "AB892X", + "84180": "AB892X", + "84184": "AB892X", + "84189": "AB892X", + "84190": "AB892X", + "84199": "AB892X", + "84201": "AB892X", + "84244": "AB892X", + "84301": "AB892X", + "84302": "AB892X", + "84304": "AB892X", + "84305": "AB892X", + "84306": "AB892X", + "84307": "AB892X", + "84308": "AB892X", + "84309": "AB892X", + "84310": "AB892X", + "84311": "AB892X", + "84312": "AB892X", + "84313": "AB892X", + "84314": "AB892X", + "84315": "AB892X", + "84316": "AB892X", + "84317": "AB892X", + "84318": "AB892X", + "84319": "AB892X", + "84320": "AB892X", + "84321": "AB892X", + "84322": "AB892X", + "84323": "AB892X", + "84324": "AB892X", + "84325": "AB892X", + "84326": "AB892X", + "84327": "AB892X", + "84328": "AB892X", + "84329": "AB892X", + "84330": "AB892X", + "84331": "AB892X", + "84332": "AB892X", + "84333": "AB892X", + "84334": "AB892X", + "84335": "AB892X", + "84336": "AB892X", + "84337": "AB892X", + "84338": "AB892X", + "84339": "AB892X", + "84340": "AB892X", + "84341": "AB892X", + "84401": "AB892X", + "84402": "AB892X", + "84403": "AB892X", + "84404": "AB892X", + "84405": "AB892X", + "84407": "AB892X", + "84408": "AB892X", + "84409": "AB892X", + "84412": "AB892X", + "84414": "AB892X", + "84415": "AB892X", + "84501": "AB892X", + "84510": "AB892X", + "84511": "AB892X", + "84512": "AB892X", + "84513": "AB892X", + "84515": "AB892X", + "84516": "AB892X", + "84518": "AB892X", + "84520": "AB892X", + "84521": "AB892X", + "84522": "AB892X", + "84523": "AB892X", + "84525": "AB892X", + "84526": "AB892X", + "84528": "AB892X", + "84529": "AB892X", + "84530": "AB892X", + "84531": "AB892X", + "84532": "AB892X", + "84533": "AB892X", + "84534": "AB892X", + "84535": "AB892X", + "84536": "AB892X", + "84537": "AB892X", + "84539": "AB892X", + "84540": "AB892X", + "84542": "AB892X", + "84601": "AB892X", + "84602": "AB892X", + "84603": "AB892X", + "84604": "AB892X", + "84605": "AB892X", + "84606": "AB892X", + "84620": "AB892X", + "84621": "AB892X", + "84622": "AB892X", + "84623": "AB892X", + "84624": "AB892X", + "84626": "AB892X", + "84627": "AB892X", + "84628": "AB892X", + "84629": "AB892X", + "84630": "AB892X", + "84631": "AB892X", + "84632": "AB892X", + "84633": "AB892X", + "84634": "AB892X", + "84635": "AB892X", + "84636": "AB892X", + "84637": "AB892X", + "84638": "AB892X", + "84639": "AB892X", + "84640": "AB892X", + "84642": "AB892X", + "84643": "AB892X", + "84644": "AB892X", + "84645": "AB892X", + "84646": "AB892X", + "84647": "AB892X", + "84648": "AB892X", + "84649": "AB892X", + "84651": "AB892X", + "84652": "AB892X", + "84653": "AB892X", + "84654": "AB892X", + "84655": "AB892X", + "84656": "AB892X", + "84657": "AB892X", + "84660": "AB892X", + "84662": "AB892X", + "84663": "AB892X", + "84664": "AB892X", + "84665": "AB892X", + "84667": "AB892X", + "84701": "AB892X", + "84710": "AB892X", + "84711": "AB892X", + "84712": "AB892X", + "84713": "AB892X", + "84714": "AB892X", + "84715": "AB892X", + "84716": "AB892X", + "84718": "AB892X", + "84719": "AB892X", + "84720": "AB892X", + "84721": "AB892X", + "84722": "AB892X", + "84723": "AB892X", + "84724": "AB892X", + "84725": "AB892X", + "84726": "AB892X", + "84728": "AB892X", + "84729": "AB892X", + "84730": "AB892X", + "84731": "AB892X", + "84732": "AB892X", + "84733": "AB892X", + "84734": "AB892X", + "84735": "AB892X", + "84736": "AB892X", + "84737": "AB892X", + "84738": "AB892X", + "84739": "AB892X", + "84740": "AB892X", + "84741": "AB892X", + "84742": "AB892X", + "84743": "AB892X", + "84744": "AB892X", + "84745": "AB892X", + "84746": "AB892X", + "84747": "AB892X", + "84749": "AB892X", + "84750": "AB892X", + "84751": "AB892X", + "84752": "AB892X", + "84753": "AB892X", + "84754": "AB892X", + "84755": "AB892X", + "84756": "AB892X", + "84757": "AB892X", + "84758": "AB892X", + "84759": "AB892X", + "84760": "AB892X", + "84761": "AB892X", + "84762": "AB892X", + "84763": "AB892X", + "84764": "AB892X", + "84765": "AB892X", + "84766": "AB892X", + "84767": "AB892X", + "84770": "AB892X", + "84771": "AB892X", + "84772": "AB892X", + "84773": "AB892X", + "84774": "AB892X", + "84775": "AB892X", + "84776": "AB892X", + "84779": "AB892X", + "84780": "AB892X", + "84781": "AB892X", + "84782": "AB892X", + "84783": "AB892X", + "84784": "AB892X", + "84790": "AB892X", + "84791": "AB892X", + "85001": "AB887X", + "85002": "AB887X", + "85003": "AB887X", + "85004": "AB887X", + "85005": "AB887X", + "85006": "AB887X", + "85007": "AB887X", + "85008": "AB887X", + "85009": "AB887X", + "85010": "AB887X", + "85011": "AB887X", + "85012": "AB887X", + "85013": "AB887X", + "85014": "AB887X", + "85015": "AB887X", + "85016": "AB887X", + "85017": "AB887X", + "85018": "AB887X", + "85019": "AB887X", + "85020": "AB887X", + "85021": "AB887X", + "85022": "AB887X", + "85023": "AB887X", + "85024": "AB887X", + "85025": "AB887X", + "85026": "AB887X", + "85027": "AB887X", + "85028": "AB887X", + "85029": "AB887X", + "85030": "AB887X", + "85031": "AB887X", + "85032": "AB887X", + "85033": "AB887X", + "85034": "AB887X", + "85035": "AB887X", + "85036": "AB887X", + "85037": "AB887X", + "85038": "AB887X", + "85039": "AB887X", + "85040": "AB887X", + "85041": "AB887X", + "85042": "AB887X", + "85043": "AB887X", + "85044": "AB887X", + "85045": "AB887X", + "85046": "AB887X", + "85048": "AB887X", + "85050": "AB887X", + "85051": "AB887X", + "85053": "AB887X", + "85054": "AB887X", + "85055": "AB887X", + "85060": "AB887X", + "85061": "AB887X", + "85062": "AB887X", + "85063": "AB887X", + "85064": "AB887X", + "85065": "AB887X", + "85066": "AB887X", + "85067": "AB887X", + "85068": "AB887X", + "85069": "AB887X", + "85070": "AB887X", + "85071": "AB887X", + "85072": "AB887X", + "85073": "AB887X", + "85074": "AB887X", + "85075": "AB887X", + "85076": "AB887X", + "85077": "AB887X", + "85078": "AB887X", + "85079": "AB887X", + "85080": "AB887X", + "85082": "AB887X", + "85083": "AB887X", + "85085": "AB887X", + "85086": "AB887X", + "85087": "AB887X", + "85098": "AB887X", + "85099": "AB887X", + "85118": "AB887X", + "85119": "AB887X", + "85120": "AB887X", + "85121": "AB887X", + "85122": "AB887X", + "85123": "AB887X", + "85128": "AB887X", + "85130": "AB887X", + "85131": "AB887X", + "85132": "AB887X", + "85135": "AB887X", + "85137": "AB887X", + "85138": "AB887X", + "85139": "AB887X", + "85140": "AB887X", + "85141": "AB887X", + "85142": "AB887X", + "85143": "AB887X", + "85147": "AB887X", + "85172": "AB887X", + "85173": "AB887X", + "85191": "AB887X", + "85192": "AB887X", + "85193": "AB887X", + "85194": "AB887X", + "85201": "AB887X", + "85202": "AB887X", + "85203": "AB887X", + "85204": "AB887X", + "85205": "AB887X", + "85206": "AB887X", + "85207": "AB887X", + "85208": "AB887X", + "85209": "AB887X", + "85210": "AB887X", + "85211": "AB887X", + "85212": "AB887X", + "85213": "AB887X", + "85214": "AB887X", + "85215": "AB887X", + "85216": "AB887X", + "85217": "AB887X", + "85218": "AB887X", + "85219": "AB887X", + "85220": "AB887X", + "85221": "AB887X", + "85222": "AB887X", + "85223": "AB887X", + "85224": "AB887X", + "85225": "AB887X", + "85226": "AB887X", + "85227": "AB887X", + "85228": "AB887X", + "85230": "AB887X", + "85231": "AB887X", + "85232": "AB887X", + "85233": "AB887X", + "85234": "AB887X", + "85235": "AB887X", + "85236": "AB887X", + "85237": "AB887X", + "85239": "AB887X", + "85241": "AB887X", + "85242": "AB887X", + "85243": "AB887X", + "85244": "AB887X", + "85245": "AB887X", + "85246": "AB887X", + "85247": "AB887X", + "85248": "AB887X", + "85249": "AB887X", + "85250": "AB887X", + "85251": "AB887X", + "85252": "AB887X", + "85253": "AB887X", + "85254": "AB887X", + "85255": "AB887X", + "85256": "AB887X", + "85257": "AB887X", + "85258": "AB887X", + "85259": "AB887X", + "85260": "AB887X", + "85261": "AB887X", + "85262": "AB887X", + "85263": "AB887X", + "85264": "AB887X", + "85266": "AB887X", + "85267": "AB887X", + "85268": "AB887X", + "85269": "AB887X", + "85271": "AB887X", + "85272": "AB887X", + "85273": "AB887X", + "85274": "AB887X", + "85275": "AB887X", + "85277": "AB887X", + "85278": "AB887X", + "85279": "AB887X", + "85280": "AB887X", + "85281": "AB887X", + "85282": "AB887X", + "85283": "AB887X", + "85284": "AB887X", + "85285": "AB887X", + "85286": "AB887X", + "85287": "AB887X", + "85289": "AB887X", + "85290": "AB887X", + "85291": "AB887X", + "85292": "AB887X", + "85295": "AB887X", + "85296": "AB887X", + "85297": "AB887X", + "85298": "AB887X", + "85299": "AB887X", + "85301": "AB887X", + "85302": "AB887X", + "85303": "AB887X", + "85304": "AB887X", + "85305": "AB887X", + "85306": "AB887X", + "85307": "AB887X", + "85308": "AB887X", + "85309": "AB887X", + "85310": "AB887X", + "85311": "AB887X", + "85312": "AB887X", + "85313": "AB887X", + "85318": "AB887X", + "85320": "AB887X", + "85321": "AB887X", + "85322": "AB887X", + "85323": "AB887X", + "85324": "AB887X", + "85325": "AB887X", + "85326": "AB887X", + "85327": "AB887X", + "85328": "AB887X", + "85329": "AB887X", + "85331": "AB887X", + "85332": "AB887X", + "85333": "AB887X", + "85334": "AB887X", + "85335": "AB887X", + "85336": "AB887X", + "85337": "AB887X", + "85338": "AB887X", + "85339": "AB887X", + "85340": "AB887X", + "85341": "AB887X", + "85342": "AB887X", + "85343": "AB887X", + "85344": "AB887X", + "85345": "AB887X", + "85346": "AB887X", + "85347": "AB887X", + "85348": "AB887X", + "85349": "AB887X", + "85350": "AB887X", + "85351": "AB887X", + "85352": "AB887X", + "85353": "AB887X", + "85354": "AB887X", + "85355": "AB887X", + "85356": "AB887X", + "85357": "AB887X", + "85358": "AB887X", + "85359": "AB887X", + "85360": "AB887X", + "85361": "AB887X", + "85362": "AB887X", + "85363": "AB887X", + "85364": "AB887X", + "85365": "AB887X", + "85366": "AB887X", + "85367": "AB887X", + "85369": "AB887X", + "85371": "AB887X", + "85372": "AB887X", + "85373": "AB887X", + "85374": "AB887X", + "85375": "AB887X", + "85376": "AB887X", + "85377": "AB887X", + "85378": "AB887X", + "85379": "AB887X", + "85380": "AB887X", + "85381": "AB887X", + "85382": "AB887X", + "85383": "AB887X", + "85385": "AB887X", + "85387": "AB887X", + "85388": "AB887X", + "85390": "AB887X", + "85392": "AB887X", + "85395": "AB887X", + "85396": "AB887X", + "85437": "AB887X", + "85501": "AB887X", + "85502": "AB887X", + "85530": "AB887X", + "85531": "AB887X", + "85532": "AB887X", + "85533": "AB887X", + "85534": "AB887X", + "85535": "AB887X", + "85536": "AB887X", + "85539": "AB887X", + "85540": "AB887X", + "85541": "AB887X", + "85542": "AB887X", + "85543": "AB887X", + "85544": "AB887X", + "85545": "AB887X", + "85546": "AB887X", + "85547": "AB887X", + "85548": "AB887X", + "85550": "AB887X", + "85551": "AB887X", + "85552": "AB887X", + "85553": "AB887X", + "85554": "AB887X", + "85601": "AB887X", + "85602": "AB887X", + "85603": "AB887X", + "85604": "AB887X", + "85605": "AB887X", + "85606": "AB887X", + "85607": "AB887X", + "85608": "AB887X", + "85609": "AB887X", + "85610": "AB887X", + "85611": "AB887X", + "85613": "AB887X", + "85614": "AB887X", + "85615": "AB887X", + "85616": "AB887X", + "85617": "AB887X", + "85618": "AB887X", + "85619": "AB887X", + "85620": "AB887X", + "85621": "AB887X", + "85622": "AB887X", + "85623": "AB887X", + "85624": "AB887X", + "85625": "AB887X", + "85626": "AB887X", + "85627": "AB887X", + "85628": "AB887X", + "85629": "AB887X", + "85630": "AB887X", + "85631": "AB887X", + "85632": "AB887X", + "85633": "AB887X", + "85634": "AB887X", + "85635": "AB887X", + "85636": "AB887X", + "85637": "AB887X", + "85638": "AB887X", + "85639": "AB887X", + "85640": "AB887X", + "85641": "AB887X", + "85643": "AB887X", + "85644": "AB887X", + "85645": "AB887X", + "85646": "AB887X", + "85648": "AB887X", + "85650": "AB887X", + "85652": "AB887X", + "85653": "AB887X", + "85654": "AB887X", + "85655": "AB887X", + "85658": "AB887X", + "85662": "AB887X", + "85670": "AB887X", + "85671": "AB887X", + "85701": "AB887X", + "85702": "AB887X", + "85703": "AB887X", + "85704": "AB887X", + "85705": "AB887X", + "85706": "AB887X", + "85707": "AB887X", + "85708": "AB887X", + "85709": "AB887X", + "85710": "AB887X", + "85711": "AB887X", + "85712": "AB887X", + "85713": "AB887X", + "85714": "AB887X", + "85715": "AB887X", + "85716": "AB887X", + "85717": "AB887X", + "85718": "AB887X", + "85719": "AB887X", + "85720": "AB887X", + "85721": "AB887X", + "85722": "AB887X", + "85723": "AB887X", + "85724": "AB887X", + "85725": "AB887X", + "85726": "AB887X", + "85728": "AB887X", + "85730": "AB887X", + "85731": "AB887X", + "85732": "AB887X", + "85733": "AB887X", + "85734": "AB887X", + "85735": "AB887X", + "85736": "AB887X", + "85737": "AB887X", + "85738": "AB887X", + "85739": "AB887X", + "85740": "AB887X", + "85741": "AB887X", + "85742": "AB887X", + "85743": "AB887X", + "85744": "AB887X", + "85745": "AB887X", + "85746": "AB887X", + "85747": "AB887X", + "85748": "AB887X", + "85749": "AB887X", + "85750": "AB887X", + "85751": "AB887X", + "85752": "AB887X", + "85754": "AB887X", + "85755": "AB887X", + "85757": "AB887X", + "85775": "AB887X", + "85777": "AB887X", + "85901": "AB887X", + "85902": "AB887X", + "85911": "AB887X", + "85912": "AB887X", + "85920": "AB887X", + "85922": "AB887X", + "85923": "AB887X", + "85924": "AB887X", + "85925": "AB887X", + "85926": "AB887X", + "85927": "AB887X", + "85928": "AB887X", + "85929": "AB887X", + "85930": "AB887X", + "85931": "AB887X", + "85932": "AB887X", + "85933": "AB887X", + "85934": "AB887X", + "85935": "AB887X", + "85936": "AB887X", + "85937": "AB887X", + "85938": "AB887X", + "85939": "AB887X", + "85940": "AB887X", + "85941": "AB887X", + "85942": "AB887X", + "86001": "AB887X", + "86002": "AB887X", + "86003": "AB887X", + "86004": "AB887X", + "86005": "AB887X", + "86011": "AB887X", + "86014": "AB887X", + "86015": "AB887X", + "86016": "AB887X", + "86017": "AB887X", + "86018": "AB887X", + "86020": "AB887X", + "86021": "AB887X", + "86022": "AB887X", + "86023": "AB887X", + "86024": "AB887X", + "86025": "AB887X", + "86028": "AB887X", + "86029": "AB887X", + "86030": "AB887X", + "86031": "AB887X", + "86032": "AB887X", + "86033": "AB887X", + "86034": "AB887X", + "86035": "AB887X", + "86036": "AB887X", + "86038": "AB887X", + "86039": "AB887X", + "86040": "AB887X", + "86042": "AB887X", + "86043": "AB887X", + "86044": "AB887X", + "86045": "AB887X", + "86046": "AB887X", + "86047": "AB887X", + "86052": "AB887X", + "86053": "AB887X", + "86054": "AB887X", + "86301": "AB887X", + "86302": "AB887X", + "86303": "AB887X", + "86304": "AB887X", + "86305": "AB887X", + "86312": "AB887X", + "86313": "AB887X", + "86314": "AB887X", + "86315": "AB887X", + "86320": "AB887X", + "86321": "AB887X", + "86322": "AB887X", + "86323": "AB887X", + "86324": "AB887X", + "86325": "AB887X", + "86326": "AB887X", + "86327": "AB887X", + "86329": "AB887X", + "86330": "AB887X", + "86331": "AB887X", + "86332": "AB887X", + "86333": "AB887X", + "86334": "AB887X", + "86335": "AB887X", + "86336": "AB887X", + "86337": "AB887X", + "86338": "AB887X", + "86339": "AB887X", + "86340": "AB887X", + "86341": "AB887X", + "86342": "AB887X", + "86343": "AB887X", + "86351": "AB887X", + "86401": "AB887X", + "86402": "AB887X", + "86403": "AB887X", + "86404": "AB887X", + "86405": "AB887X", + "86406": "AB887X", + "86409": "AB887X", + "86411": "AB887X", + "86412": "AB887X", + "86413": "AB887X", + "86426": "AB887X", + "86427": "AB887X", + "86429": "AB887X", + "86430": "AB887X", + "86431": "AB887X", + "86432": "AB887X", + "86433": "AB887X", + "86434": "AB887X", + "86435": "AB887X", + "86436": "AB887X", + "86437": "AB887X", + "86438": "AB887X", + "86439": "AB887X", + "86440": "AB887X", + "86441": "AB887X", + "86442": "AB887X", + "86443": "AB887X", + "86444": "AB887X", + "86445": "AB887X", + "86446": "AB887X", + "86502": "AB889X", + "86503": "AB889X", + "86504": "AB889X", + "86505": "AB887X", + "86506": "AB889X", + "86507": "AB889X", + "86508": "AB889X", + "86510": "AB887X", + "86511": "AB889X", + "86512": "AB889X", + "86514": "AB889X", + "86515": "AB889X", + "86520": "AB887X", + "86535": "AB889X", + "86538": "AB889X", + "86540": "AB889X", + "86544": "AB889X", + "86545": "AB889X", + "86547": "AB889X", + "86556": "AB887X", + "87001": "AB889X", + "87002": "AB889X", + "87004": "AB889X", + "87005": "AB889X", + "87006": "AB889X", + "87007": "AB889X", + "87008": "AB889X", + "87009": "AB889X", + "87010": "AB889X", + "87011": "AB889X", + "87012": "AB889X", + "87013": "AB889X", + "87014": "AB889X", + "87015": "AB889X", + "87016": "AB889X", + "87017": "AB889X", + "87018": "AB889X", + "87020": "AB889X", + "87021": "AB889X", + "87022": "AB889X", + "87023": "AB889X", + "87024": "AB889X", + "87025": "AB889X", + "87026": "AB889X", + "87027": "AB889X", + "87028": "AB889X", + "87029": "AB889X", + "87031": "AB889X", + "87032": "AB889X", + "87034": "AB889X", + "87035": "AB889X", + "87036": "AB889X", + "87037": "AB889X", + "87038": "AB889X", + "87040": "AB889X", + "87041": "AB889X", + "87042": "AB889X", + "87043": "AB889X", + "87044": "AB889X", + "87045": "AB889X", + "87046": "AB889X", + "87047": "AB889X", + "87048": "AB889X", + "87049": "AB889X", + "87051": "AB889X", + "87052": "AB889X", + "87053": "AB889X", + "87056": "AB889X", + "87059": "AB889X", + "87060": "AB889X", + "87061": "AB889X", + "87062": "AB889X", + "87063": "AB889X", + "87064": "AB889X", + "87068": "AB889X", + "87070": "AB889X", + "87072": "AB889X", + "87083": "AB889X", + "87101": "AB889X", + "87102": "AB889X", + "87103": "AB889X", + "87104": "AB889X", + "87105": "AB889X", + "87106": "AB889X", + "87107": "AB889X", + "87108": "AB889X", + "87109": "AB889X", + "87110": "AB889X", + "87111": "AB889X", + "87112": "AB889X", + "87113": "AB889X", + "87114": "AB889X", + "87115": "AB889X", + "87116": "AB889X", + "87117": "AB889X", + "87119": "AB889X", + "87120": "AB889X", + "87121": "AB889X", + "87122": "AB889X", + "87123": "AB889X", + "87124": "AB889X", + "87125": "AB889X", + "87131": "AB889X", + "87144": "AB889X", + "87151": "AB889X", + "87153": "AB889X", + "87154": "AB889X", + "87158": "AB889X", + "87165": "AB889X", + "87174": "AB889X", + "87176": "AB889X", + "87181": "AB889X", + "87184": "AB889X", + "87185": "AB889X", + "87187": "AB889X", + "87190": "AB889X", + "87191": "AB889X", + "87192": "AB889X", + "87193": "AB889X", + "87194": "AB889X", + "87195": "AB889X", + "87196": "AB889X", + "87197": "AB889X", + "87198": "AB889X", + "87199": "AB889X", + "87301": "AB889X", + "87302": "AB889X", + "87305": "AB889X", + "87310": "AB889X", + "87311": "AB889X", + "87312": "AB889X", + "87313": "AB889X", + "87315": "AB889X", + "87316": "AB889X", + "87317": "AB889X", + "87319": "AB889X", + "87320": "AB889X", + "87321": "AB889X", + "87322": "AB889X", + "87323": "AB889X", + "87325": "AB889X", + "87326": "AB889X", + "87327": "AB889X", + "87328": "AB889X", + "87347": "AB889X", + "87357": "AB889X", + "87364": "AB889X", + "87365": "AB889X", + "87375": "AB889X", + "87401": "AB889X", + "87402": "AB889X", + "87410": "AB889X", + "87412": "AB889X", + "87413": "AB889X", + "87415": "AB889X", + "87416": "AB889X", + "87417": "AB889X", + "87418": "AB889X", + "87419": "AB889X", + "87420": "AB889X", + "87421": "AB889X", + "87455": "AB889X", + "87461": "AB889X", + "87499": "AB889X", + "87501": "AB889X", + "87502": "AB889X", + "87503": "AB889X", + "87504": "AB889X", + "87505": "AB889X", + "87506": "AB889X", + "87507": "AB889X", + "87508": "AB889X", + "87509": "AB889X", + "87510": "AB889X", + "87511": "AB889X", + "87512": "AB889X", + "87513": "AB889X", + "87514": "AB889X", + "87515": "AB889X", + "87516": "AB889X", + "87517": "AB889X", + "87518": "AB889X", + "87519": "AB889X", + "87520": "AB889X", + "87521": "AB889X", + "87522": "AB889X", + "87523": "AB889X", + "87524": "AB889X", + "87525": "AB889X", + "87527": "AB889X", + "87528": "AB889X", + "87529": "AB889X", + "87530": "AB889X", + "87531": "AB889X", + "87532": "AB889X", + "87533": "AB889X", + "87535": "AB889X", + "87537": "AB889X", + "87538": "AB889X", + "87539": "AB889X", + "87540": "AB889X", + "87543": "AB889X", + "87544": "AB890X", + "87545": "AB890X", + "87548": "AB889X", + "87549": "AB889X", + "87551": "AB889X", + "87552": "AB889X", + "87553": "AB889X", + "87554": "AB889X", + "87556": "AB889X", + "87557": "AB889X", + "87558": "AB889X", + "87560": "AB889X", + "87562": "AB889X", + "87564": "AB889X", + "87565": "AB889X", + "87566": "AB889X", + "87567": "AB889X", + "87569": "AB889X", + "87571": "AB889X", + "87573": "AB889X", + "87574": "AB889X", + "87575": "AB889X", + "87576": "AB889X", + "87577": "AB889X", + "87578": "AB889X", + "87579": "AB889X", + "87580": "AB889X", + "87581": "AB889X", + "87582": "AB889X", + "87583": "AB889X", + "87592": "AB889X", + "87594": "AB889X", + "87701": "AB889X", + "87710": "AB889X", + "87711": "AB889X", + "87712": "AB889X", + "87713": "AB889X", + "87714": "AB889X", + "87715": "AB889X", + "87718": "AB889X", + "87722": "AB889X", + "87723": "AB889X", + "87724": "AB889X", + "87728": "AB889X", + "87729": "AB889X", + "87730": "AB889X", + "87731": "AB889X", + "87732": "AB889X", + "87733": "AB889X", + "87734": "AB889X", + "87735": "AB889X", + "87736": "AB889X", + "87740": "AB889X", + "87742": "AB889X", + "87743": "AB889X", + "87745": "AB889X", + "87746": "AB889X", + "87747": "AB889X", + "87749": "AB889X", + "87750": "AB889X", + "87752": "AB889X", + "87753": "AB889X", + "87801": "AB889X", + "87820": "AB889X", + "87821": "AB889X", + "87823": "AB889X", + "87824": "AB889X", + "87825": "AB889X", + "87827": "AB889X", + "87828": "AB889X", + "87829": "AB889X", + "87830": "AB889X", + "87831": "AB889X", + "87832": "AB889X", + "87901": "AB889X", + "87930": "AB889X", + "87931": "AB889X", + "87933": "AB889X", + "87935": "AB889X", + "87936": "AB889X", + "87937": "AB889X", + "87939": "AB889X", + "87940": "AB889X", + "87941": "AB889X", + "87942": "AB889X", + "87943": "AB889X", + "88001": "AB889X", + "88002": "AB889X", + "88003": "AB889X", + "88004": "AB889X", + "88005": "AB889X", + "88006": "AB889X", + "88007": "AB889X", + "88008": "AB889X", + "88009": "AB889X", + "88011": "AB889X", + "88012": "AB889X", + "88013": "AB889X", + "88020": "AB889X", + "88021": "AB889X", + "88022": "AB889X", + "88023": "AB889X", + "88024": "AB889X", + "88025": "AB889X", + "88026": "AB889X", + "88027": "AB889X", + "88028": "AB889X", + "88029": "AB889X", + "88030": "AB889X", + "88031": "AB889X", + "88032": "AB889X", + "88033": "AB889X", + "88034": "AB889X", + "88036": "AB889X", + "88038": "AB889X", + "88039": "AB889X", + "88040": "AB889X", + "88041": "AB889X", + "88042": "AB889X", + "88043": "AB889X", + "88044": "AB889X", + "88045": "AB889X", + "88046": "AB889X", + "88047": "AB889X", + "88048": "AB889X", + "88049": "AB889X", + "88051": "AB889X", + "88052": "AB889X", + "88053": "AB889X", + "88054": "AB889X", + "88055": "AB889X", + "88056": "AB889X", + "88058": "AB889X", + "88061": "AB889X", + "88062": "AB889X", + "88063": "AB889X", + "88065": "AB889X", + "88072": "AB889X", + "88081": "AB889X", + "88101": "AB900X", + "88102": "AB900X", + "88103": "AB900X", + "88112": "AB900X", + "88113": "AB889X", + "88114": "AB889X", + "88115": "AB889X", + "88116": "AB889X", + "88118": "AB889X", + "88119": "AB900X", + "88120": "AB900X", + "88121": "AB889X", + "88122": "AB889X", + "88123": "AB889X", + "88124": "AB900X", + "88125": "AB889X", + "88126": "AB889X", + "88130": "AB889X", + "88132": "AB889X", + "88133": "AB900X", + "88134": "AB900X", + "88135": "AB900X", + "88136": "AB900X", + "88201": "AB889X", + "88202": "AB889X", + "88203": "AB889X", + "88210": "AB889X", + "88211": "AB889X", + "88213": "AB889X", + "88220": "AB889X", + "88221": "AB889X", + "88230": "AB889X", + "88231": "AB889X", + "88232": "AB889X", + "88240": "AB889X", + "88241": "AB889X", + "88242": "AB889X", + "88244": "AB889X", + "88250": "AB889X", + "88252": "AB889X", + "88253": "AB889X", + "88254": "AB889X", + "88255": "AB889X", + "88256": "AB889X", + "88260": "AB889X", + "88262": "AB889X", + "88263": "AB889X", + "88264": "AB889X", + "88265": "AB889X", + "88267": "AB889X", + "88268": "AB889X", + "88301": "AB889X", + "88310": "AB889X", + "88311": "AB889X", + "88312": "AB889X", + "88314": "AB889X", + "88316": "AB889X", + "88317": "AB889X", + "88318": "AB889X", + "88321": "AB889X", + "88323": "AB889X", + "88324": "AB889X", + "88325": "AB889X", + "88330": "AB889X", + "88336": "AB889X", + "88337": "AB889X", + "88338": "AB889X", + "88339": "AB889X", + "88340": "AB889X", + "88341": "AB889X", + "88342": "AB889X", + "88343": "AB889X", + "88344": "AB889X", + "88345": "AB889X", + "88346": "AB889X", + "88347": "AB889X", + "88348": "AB889X", + "88349": "AB889X", + "88350": "AB889X", + "88351": "AB889X", + "88352": "AB889X", + "88353": "AB889X", + "88354": "AB889X", + "88355": "AB889X", + "88401": "AB889X", + "88410": "AB889X", + "88411": "AB889X", + "88414": "AB889X", + "88415": "AB889X", + "88416": "AB889X", + "88417": "AB889X", + "88418": "AB889X", + "88419": "AB889X", + "88421": "AB889X", + "88422": "AB889X", + "88424": "AB889X", + "88426": "AB889X", + "88427": "AB889X", + "88430": "AB889X", + "88431": "AB889X", + "88433": "AB889X", + "88434": "AB889X", + "88435": "AB889X", + "88436": "AB889X", + "88439": "AB889X", + "88510": "AB889X", + "88511": "AB889X", + "88512": "AB889X", + "88513": "AB889X", + "88514": "AB889X", + "88515": "AB889X", + "88516": "AB889X", + "88517": "AB889X", + "88518": "AB889X", + "88519": "AB889X", + "88520": "AB889X", + "88521": "AB889X", + "88523": "AB889X", + "88524": "AB889X", + "88525": "AB889X", + "88526": "AB889X", + "88527": "AB889X", + "88528": "AB889X", + "88529": "AB889X", + "88530": "AB889X", + "88531": "AB889X", + "88532": "AB889X", + "88533": "AB889X", + "88534": "AB889X", + "88535": "AB889X", + "88536": "AB889X", + "88538": "AB889X", + "88539": "AB889X", + "88540": "AB889X", + "88541": "AB889X", + "88542": "AB889X", + "88543": "AB889X", + "88544": "AB889X", + "88545": "AB889X", + "88546": "AB889X", + "88547": "AB889X", + "88548": "AB889X", + "88549": "AB889X", + "88550": "AB889X", + "88553": "AB889X", + "88554": "AB889X", + "88555": "AB889X", + "88556": "AB889X", + "88557": "AB889X", + "88558": "AB889X", + "88559": "AB889X", + "88560": "AB889X", + "88561": "AB889X", + "88562": "AB889X", + "88563": "AB889X", + "88565": "AB889X", + "88566": "AB889X", + "88567": "AB889X", + "88568": "AB889X", + "88569": "AB889X", + "88570": "AB889X", + "88571": "AB889X", + "88572": "AB889X", + "88573": "AB889X", + "88574": "AB889X", + "88575": "AB889X", + "88576": "AB889X", + "88577": "AB889X", + "88578": "AB889X", + "88579": "AB889X", + "88580": "AB889X", + "88581": "AB889X", + "88582": "AB889X", + "88583": "AB889X", + "88584": "AB889X", + "88585": "AB889X", + "88586": "AB889X", + "88587": "AB889X", + "88588": "AB889X", + "88589": "AB889X", + "88590": "AB889X", + "88595": "AB889X", + "90001": "AB890X", + "90002": "AB890X", + "90003": "AB890X", + "90004": "AB890X", + "90005": "AB890X", + "90006": "AB890X", + "90007": "AB890X", + "90008": "AB890X", + "90009": "AB890X", + "90010": "AB890X", + "90011": "AB890X", + "90012": "AB890X", + "90013": "AB890X", + "90014": "AB890X", + "90015": "AB890X", + "90016": "AB890X", + "90017": "AB890X", + "90018": "AB890X", + "90019": "AB890X", + "90020": "AB890X", + "90021": "AB890X", + "90022": "AB890X", + "90023": "AB890X", + "90024": "AB890X", + "90025": "AB890X", + "90026": "AB890X", + "90027": "AB890X", + "90028": "AB890X", + "90029": "AB890X", + "90030": "AB890X", + "90031": "AB890X", + "90032": "AB890X", + "90033": "AB890X", + "90034": "AB890X", + "90035": "AB890X", + "90036": "AB890X", + "90037": "AB890X", + "90038": "AB890X", + "90039": "AB890X", + "90040": "AB890X", + "90041": "AB890X", + "90042": "AB890X", + "90043": "AB890X", + "90044": "AB890X", + "90045": "AB890X", + "90046": "AB890X", + "90047": "AB890X", + "90048": "AB890X", + "90049": "AB890X", + "90050": "AB890X", + "90051": "AB890X", + "90052": "AB890X", + "90053": "AB890X", + "90054": "AB890X", + "90055": "AB890X", + "90056": "AB890X", + "90057": "AB890X", + "90058": "AB890X", + "90059": "AB890X", + "90060": "AB890X", + "90061": "AB890X", + "90062": "AB890X", + "90063": "AB890X", + "90064": "AB890X", + "90065": "AB890X", + "90066": "AB890X", + "90067": "AB890X", + "90068": "AB890X", + "90069": "AB890X", + "90070": "AB890X", + "90071": "AB890X", + "90072": "AB890X", + "90073": "AB890X", + "90074": "AB890X", + "90075": "AB890X", + "90076": "AB890X", + "90077": "AB890X", + "90078": "AB890X", + "90079": "AB890X", + "90080": "AB890X", + "90081": "AB890X", + "90082": "AB890X", + "90083": "AB890X", + "90084": "AB890X", + "90086": "AB890X", + "90087": "AB890X", + "90088": "AB890X", + "90089": "AB890X", + "90091": "AB890X", + "90093": "AB890X", + "90094": "AB890X", + "90095": "AB890X", + "90096": "AB890X", + "90099": "AB890X", + "90101": "AB890X", + "90102": "AB890X", + "90103": "AB890X", + "90189": "AB890X", + "90201": "AB890X", + "90202": "AB890X", + "90209": "AB890X", + "90210": "AB890X", + "90211": "AB890X", + "90212": "AB890X", + "90213": "AB890X", + "90220": "AB890X", + "90221": "AB890X", + "90222": "AB890X", + "90223": "AB890X", + "90224": "AB890X", + "90230": "AB890X", + "90231": "AB890X", + "90232": "AB890X", + "90233": "AB890X", + "90239": "AB890X", + "90240": "AB890X", + "90241": "AB890X", + "90242": "AB890X", + "90245": "AB890X", + "90247": "AB890X", + "90248": "AB890X", + "90249": "AB890X", + "90250": "AB890X", + "90251": "AB890X", + "90254": "AB890X", + "90255": "AB890X", + "90260": "AB890X", + "90261": "AB890X", + "90262": "AB890X", + "90263": "AB890X", + "90264": "AB890X", + "90265": "AB890X", + "90266": "AB890X", + "90267": "AB890X", + "90270": "AB890X", + "90272": "AB890X", + "90274": "AB890X", + "90275": "AB890X", + "90277": "AB890X", + "90278": "AB890X", + "90280": "AB890X", + "90290": "AB890X", + "90291": "AB890X", + "90292": "AB890X", + "90293": "AB890X", + "90294": "AB890X", + "90295": "AB890X", + "90296": "AB890X", + "90301": "AB890X", + "90302": "AB890X", + "90303": "AB890X", + "90304": "AB890X", + "90305": "AB890X", + "90306": "AB890X", + "90307": "AB890X", + "90308": "AB890X", + "90309": "AB890X", + "90310": "AB890X", + "90311": "AB890X", + "90312": "AB890X", + "90313": "AB890X", + "90397": "AB890X", + "90398": "AB890X", + "90401": "AB890X", + "90402": "AB890X", + "90403": "AB890X", + "90404": "AB890X", + "90405": "AB890X", + "90406": "AB890X", + "90407": "AB890X", + "90408": "AB890X", + "90409": "AB890X", + "90410": "AB890X", + "90411": "AB890X", + "90501": "AB890X", + "90502": "AB890X", + "90503": "AB890X", + "90504": "AB890X", + "90505": "AB890X", + "90506": "AB890X", + "90507": "AB890X", + "90508": "AB890X", + "90509": "AB890X", + "90510": "AB890X", + "90601": "AB890X", + "90602": "AB890X", + "90603": "AB890X", + "90604": "AB890X", + "90605": "AB890X", + "90606": "AB890X", + "90607": "AB890X", + "90608": "AB890X", + "90609": "AB890X", + "90610": "AB890X", + "90612": "AB890X", + "90620": "AB890X", + "90621": "AB890X", + "90622": "AB890X", + "90623": "AB890X", + "90624": "AB890X", + "90630": "AB890X", + "90631": "AB890X", + "90632": "AB890X", + "90633": "AB890X", + "90637": "AB890X", + "90638": "AB890X", + "90639": "AB890X", + "90640": "AB890X", + "90650": "AB890X", + "90651": "AB890X", + "90652": "AB890X", + "90659": "AB890X", + "90660": "AB890X", + "90661": "AB890X", + "90662": "AB890X", + "90670": "AB890X", + "90671": "AB890X", + "90680": "AB890X", + "90701": "AB890X", + "90702": "AB890X", + "90703": "AB890X", + "90704": "AB890X", + "90706": "AB890X", + "90707": "AB890X", + "90710": "AB890X", + "90711": "AB890X", + "90712": "AB890X", + "90713": "AB890X", + "90714": "AB890X", + "90715": "AB890X", + "90716": "AB890X", + "90717": "AB890X", + "90720": "AB890X", + "90721": "AB890X", + "90723": "AB890X", + "90731": "AB890X", + "90732": "AB890X", + "90733": "AB890X", + "90734": "AB890X", + "90740": "AB890X", + "90742": "AB890X", + "90743": "AB890X", + "90744": "AB890X", + "90745": "AB890X", + "90746": "AB890X", + "90747": "AB890X", + "90748": "AB890X", + "90749": "AB890X", + "90755": "AB890X", + "90801": "AB890X", + "90802": "AB890X", + "90803": "AB890X", + "90804": "AB890X", + "90805": "AB890X", + "90806": "AB890X", + "90807": "AB890X", + "90808": "AB890X", + "90809": "AB890X", + "90810": "AB890X", + "90813": "AB890X", + "90814": "AB890X", + "90815": "AB890X", + "90822": "AB890X", + "90831": "AB890X", + "90832": "AB890X", + "90833": "AB890X", + "90834": "AB890X", + "90835": "AB890X", + "90840": "AB890X", + "90842": "AB890X", + "90844": "AB890X", + "90845": "AB890X", + "90846": "AB890X", + "90847": "AB890X", + "90848": "AB890X", + "90853": "AB890X", + "90888": "AB890X", + "90895": "AB890X", + "90899": "AB890X", + "91001": "AB890X", + "91003": "AB890X", + "91006": "AB890X", + "91007": "AB890X", + "91009": "AB890X", + "91010": "AB890X", + "91011": "AB890X", + "91012": "AB890X", + "91016": "AB890X", + "91017": "AB890X", + "91020": "AB890X", + "91021": "AB890X", + "91023": "AB890X", + "91024": "AB890X", + "91025": "AB890X", + "91030": "AB890X", + "91031": "AB890X", + "91040": "AB890X", + "91041": "AB890X", + "91042": "AB890X", + "91043": "AB890X", + "91046": "AB890X", + "91066": "AB890X", + "91077": "AB890X", + "91101": "AB890X", + "91102": "AB890X", + "91103": "AB890X", + "91104": "AB890X", + "91105": "AB890X", + "91106": "AB890X", + "91107": "AB890X", + "91108": "AB890X", + "91109": "AB890X", + "91110": "AB890X", + "91114": "AB890X", + "91115": "AB890X", + "91116": "AB890X", + "91117": "AB890X", + "91118": "AB890X", + "91121": "AB890X", + "91123": "AB890X", + "91124": "AB890X", + "91125": "AB890X", + "91126": "AB890X", + "91129": "AB890X", + "91131": "AB890X", + "91182": "AB890X", + "91184": "AB890X", + "91185": "AB890X", + "91188": "AB890X", + "91189": "AB890X", + "91191": "AB890X", + "91199": "AB890X", + "91201": "AB890X", + "91202": "AB890X", + "91203": "AB890X", + "91204": "AB890X", + "91205": "AB890X", + "91206": "AB890X", + "91207": "AB890X", + "91208": "AB890X", + "91209": "AB890X", + "91210": "AB890X", + "91214": "AB890X", + "91221": "AB890X", + "91222": "AB890X", + "91224": "AB890X", + "91225": "AB890X", + "91226": "AB890X", + "91301": "AB890X", + "91302": "AB890X", + "91303": "AB890X", + "91304": "AB890X", + "91305": "AB890X", + "91306": "AB890X", + "91307": "AB890X", + "91308": "AB890X", + "91309": "AB890X", + "91310": "AB890X", + "91311": "AB890X", + "91313": "AB890X", + "91316": "AB890X", + "91319": "AB890X", + "91320": "AB890X", + "91321": "AB890X", + "91322": "AB890X", + "91324": "AB890X", + "91325": "AB890X", + "91326": "AB890X", + "91327": "AB890X", + "91328": "AB890X", + "91329": "AB890X", + "91330": "AB890X", + "91331": "AB890X", + "91333": "AB890X", + "91334": "AB890X", + "91335": "AB890X", + "91337": "AB890X", + "91340": "AB890X", + "91341": "AB890X", + "91342": "AB890X", + "91343": "AB890X", + "91344": "AB890X", + "91345": "AB890X", + "91346": "AB890X", + "91350": "AB890X", + "91351": "AB890X", + "91352": "AB890X", + "91353": "AB890X", + "91354": "AB890X", + "91355": "AB890X", + "91356": "AB890X", + "91357": "AB890X", + "91358": "AB890X", + "91359": "AB890X", + "91360": "AB890X", + "91361": "AB890X", + "91362": "AB890X", + "91363": "AB890X", + "91364": "AB890X", + "91365": "AB890X", + "91367": "AB890X", + "91371": "AB890X", + "91372": "AB890X", + "91376": "AB890X", + "91377": "AB890X", + "91380": "AB890X", + "91381": "AB890X", + "91382": "AB890X", + "91383": "AB890X", + "91384": "AB890X", + "91385": "AB890X", + "91386": "AB890X", + "91387": "AB890X", + "91388": "AB890X", + "91390": "AB890X", + "91392": "AB890X", + "91393": "AB890X", + "91394": "AB890X", + "91395": "AB890X", + "91396": "AB890X", + "91399": "AB890X", + "91401": "AB890X", + "91402": "AB890X", + "91403": "AB890X", + "91404": "AB890X", + "91405": "AB890X", + "91406": "AB890X", + "91407": "AB890X", + "91408": "AB890X", + "91409": "AB890X", + "91410": "AB890X", + "91411": "AB890X", + "91412": "AB890X", + "91413": "AB890X", + "91416": "AB890X", + "91423": "AB890X", + "91426": "AB890X", + "91436": "AB890X", + "91470": "AB890X", + "91482": "AB890X", + "91495": "AB890X", + "91496": "AB890X", + "91497": "AB890X", + "91499": "AB890X", + "91501": "AB890X", + "91502": "AB890X", + "91503": "AB890X", + "91504": "AB890X", + "91505": "AB890X", + "91506": "AB890X", + "91507": "AB890X", + "91508": "AB890X", + "91510": "AB890X", + "91521": "AB890X", + "91522": "AB890X", + "91523": "AB890X", + "91526": "AB890X", + "91601": "AB890X", + "91602": "AB890X", + "91603": "AB890X", + "91604": "AB890X", + "91605": "AB890X", + "91606": "AB890X", + "91607": "AB890X", + "91608": "AB890X", + "91609": "AB890X", + "91610": "AB890X", + "91611": "AB890X", + "91612": "AB890X", + "91614": "AB890X", + "91615": "AB890X", + "91616": "AB890X", + "91617": "AB890X", + "91618": "AB890X", + "91701": "AB890X", + "91702": "AB890X", + "91706": "AB890X", + "91708": "AB890X", + "91709": "AB890X", + "91710": "AB890X", + "91711": "AB890X", + "91714": "AB890X", + "91715": "AB890X", + "91716": "AB890X", + "91722": "AB890X", + "91723": "AB890X", + "91724": "AB890X", + "91729": "AB890X", + "91730": "AB890X", + "91731": "AB890X", + "91732": "AB890X", + "91733": "AB890X", + "91734": "AB890X", + "91735": "AB890X", + "91737": "AB890X", + "91739": "AB890X", + "91740": "AB890X", + "91741": "AB890X", + "91743": "AB890X", + "91744": "AB890X", + "91745": "AB890X", + "91746": "AB890X", + "91747": "AB890X", + "91748": "AB890X", + "91749": "AB890X", + "91750": "AB890X", + "91752": "AB890X", + "91754": "AB890X", + "91755": "AB890X", + "91756": "AB890X", + "91758": "AB890X", + "91759": "AB890X", + "91761": "AB890X", + "91762": "AB890X", + "91763": "AB890X", + "91764": "AB890X", + "91765": "AB890X", + "91766": "AB890X", + "91767": "AB890X", + "91768": "AB890X", + "91769": "AB890X", + "91770": "AB890X", + "91771": "AB890X", + "91772": "AB890X", + "91773": "AB890X", + "91775": "AB890X", + "91776": "AB890X", + "91778": "AB890X", + "91780": "AB890X", + "91784": "AB890X", + "91785": "AB890X", + "91786": "AB890X", + "91788": "AB890X", + "91789": "AB890X", + "91790": "AB890X", + "91791": "AB890X", + "91792": "AB890X", + "91793": "AB890X", + "91795": "AB890X", + "91797": "AB890X", + "91798": "AB890X", + "91799": "AB890X", + "91801": "AB890X", + "91802": "AB890X", + "91803": "AB890X", + "91804": "AB890X", + "91841": "AB890X", + "91896": "AB890X", + "91899": "AB890X", + "91901": "AB890X", + "91902": "AB890X", + "91903": "AB890X", + "91905": "AB890X", + "91906": "AB890X", + "91908": "AB890X", + "91909": "AB890X", + "91910": "AB890X", + "91911": "AB890X", + "91912": "AB890X", + "91913": "AB890X", + "91914": "AB890X", + "91915": "AB890X", + "91916": "AB890X", + "91917": "AB890X", + "91921": "AB890X", + "91931": "AB890X", + "91932": "AB890X", + "91933": "AB890X", + "91934": "AB890X", + "91935": "AB890X", + "91941": "AB890X", + "91942": "AB890X", + "91943": "AB890X", + "91944": "AB890X", + "91945": "AB890X", + "91946": "AB890X", + "91947": "AB890X", + "91948": "AB890X", + "91950": "AB890X", + "91951": "AB890X", + "91962": "AB890X", + "91963": "AB890X", + "91976": "AB890X", + "91977": "AB890X", + "91978": "AB890X", + "91979": "AB890X", + "91980": "AB890X", + "91987": "AB890X", + "91990": "AB890X", + "92003": "AB890X", + "92004": "AB890X", + "92007": "AB890X", + "92008": "AB890X", + "92009": "AB890X", + "92010": "AB890X", + "92011": "AB890X", + "92013": "AB890X", + "92014": "AB890X", + "92018": "AB890X", + "92019": "AB890X", + "92020": "AB890X", + "92021": "AB890X", + "92022": "AB890X", + "92023": "AB890X", + "92024": "AB890X", + "92025": "AB890X", + "92026": "AB890X", + "92027": "AB890X", + "92028": "AB890X", + "92029": "AB890X", + "92030": "AB890X", + "92033": "AB890X", + "92036": "AB890X", + "92037": "AB890X", + "92038": "AB890X", + "92039": "AB890X", + "92040": "AB890X", + "92046": "AB890X", + "92049": "AB890X", + "92051": "AB890X", + "92052": "AB890X", + "92054": "AB890X", + "92055": "AB890X", + "92056": "AB890X", + "92057": "AB890X", + "92058": "AB890X", + "92059": "AB890X", + "92060": "AB890X", + "92061": "AB890X", + "92064": "AB890X", + "92065": "AB890X", + "92066": "AB890X", + "92067": "AB890X", + "92068": "AB890X", + "92069": "AB890X", + "92070": "AB890X", + "92071": "AB890X", + "92072": "AB890X", + "92074": "AB890X", + "92075": "AB890X", + "92078": "AB890X", + "92079": "AB890X", + "92081": "AB890X", + "92082": "AB890X", + "92083": "AB890X", + "92084": "AB890X", + "92085": "AB890X", + "92086": "AB890X", + "92088": "AB890X", + "92090": "AB890X", + "92091": "AB890X", + "92092": "AB890X", + "92093": "AB890X", + "92096": "AB890X", + "92101": "AB890X", + "92102": "AB890X", + "92103": "AB890X", + "92104": "AB890X", + "92105": "AB890X", + "92106": "AB890X", + "92107": "AB890X", + "92108": "AB890X", + "92109": "AB890X", + "92110": "AB890X", + "92111": "AB890X", + "92112": "AB890X", + "92113": "AB890X", + "92114": "AB890X", + "92115": "AB890X", + "92116": "AB890X", + "92117": "AB890X", + "92118": "AB890X", + "92119": "AB890X", + "92120": "AB890X", + "92121": "AB890X", + "92122": "AB890X", + "92123": "AB890X", + "92124": "AB890X", + "92126": "AB890X", + "92127": "AB890X", + "92128": "AB890X", + "92129": "AB890X", + "92130": "AB890X", + "92131": "AB890X", + "92132": "AB890X", + "92133": "AB890X", + "92134": "AB890X", + "92135": "AB890X", + "92136": "AB890X", + "92137": "AB890X", + "92138": "AB890X", + "92139": "AB890X", + "92140": "AB890X", + "92142": "AB890X", + "92143": "AB890X", + "92145": "AB890X", + "92147": "AB890X", + "92149": "AB890X", + "92150": "AB890X", + "92152": "AB890X", + "92153": "AB890X", + "92154": "AB890X", + "92155": "AB890X", + "92158": "AB890X", + "92159": "AB890X", + "92160": "AB890X", + "92161": "AB890X", + "92162": "AB890X", + "92163": "AB890X", + "92164": "AB890X", + "92165": "AB890X", + "92166": "AB890X", + "92167": "AB890X", + "92168": "AB890X", + "92169": "AB890X", + "92170": "AB890X", + "92171": "AB890X", + "92172": "AB890X", + "92173": "AB890X", + "92174": "AB890X", + "92175": "AB890X", + "92176": "AB890X", + "92177": "AB890X", + "92178": "AB890X", + "92179": "AB890X", + "92182": "AB890X", + "92184": "AB890X", + "92186": "AB890X", + "92187": "AB890X", + "92190": "AB890X", + "92191": "AB890X", + "92192": "AB890X", + "92193": "AB890X", + "92194": "AB890X", + "92195": "AB890X", + "92196": "AB890X", + "92197": "AB890X", + "92198": "AB890X", + "92199": "AB890X", + "92201": "AB890X", + "92202": "AB890X", + "92203": "AB890X", + "92210": "AB890X", + "92211": "AB890X", + "92220": "AB890X", + "92222": "AB887X", + "92223": "AB890X", + "92225": "AB887X", + "92226": "AB890X", + "92227": "AB887X", + "92230": "AB890X", + "92231": "AB887X", + "92232": "AB887X", + "92233": "AB887X", + "92234": "AB890X", + "92235": "AB890X", + "92236": "AB890X", + "92239": "AB890X", + "92240": "AB890X", + "92241": "AB890X", + "92242": "AB890X", + "92243": "AB887X", + "92244": "AB887X", + "92247": "AB890X", + "92248": "AB890X", + "92249": "AB887X", + "92250": "AB887X", + "92251": "AB887X", + "92252": "AB890X", + "92253": "AB890X", + "92254": "AB890X", + "92255": "AB890X", + "92256": "AB890X", + "92257": "AB887X", + "92258": "AB890X", + "92259": "AB887X", + "92260": "AB890X", + "92261": "AB890X", + "92262": "AB890X", + "92263": "AB890X", + "92264": "AB890X", + "92266": "AB887X", + "92267": "AB890X", + "92268": "AB890X", + "92270": "AB890X", + "92273": "AB887X", + "92274": "AB890X", + "92275": "AB887X", + "92276": "AB890X", + "92277": "AB890X", + "92278": "AB890X", + "92280": "AB890X", + "92281": "AB887X", + "92282": "AB890X", + "92283": "AB887X", + "92284": "AB890X", + "92285": "AB890X", + "92286": "AB890X", + "92292": "AB890X", + "92301": "AB890X", + "92304": "AB890X", + "92305": "AB890X", + "92307": "AB890X", + "92308": "AB890X", + "92309": "AB890X", + "92310": "AB890X", + "92311": "AB890X", + "92312": "AB890X", + "92313": "AB890X", + "92314": "AB890X", + "92315": "AB890X", + "92316": "AB890X", + "92317": "AB890X", + "92318": "AB890X", + "92320": "AB890X", + "92321": "AB890X", + "92322": "AB890X", + "92323": "AB890X", + "92324": "AB890X", + "92325": "AB890X", + "92326": "AB890X", + "92327": "AB890X", + "92328": "AB890X", + "92329": "AB890X", + "92331": "AB890X", + "92332": "AB890X", + "92333": "AB890X", + "92334": "AB890X", + "92335": "AB890X", + "92336": "AB890X", + "92337": "AB890X", + "92338": "AB890X", + "92339": "AB890X", + "92340": "AB890X", + "92341": "AB890X", + "92342": "AB890X", + "92344": "AB890X", + "92345": "AB890X", + "92346": "AB890X", + "92347": "AB890X", + "92350": "AB890X", + "92352": "AB890X", + "92354": "AB890X", + "92356": "AB890X", + "92357": "AB890X", + "92358": "AB890X", + "92359": "AB890X", + "92363": "AB890X", + "92364": "AB890X", + "92365": "AB890X", + "92366": "AB890X", + "92368": "AB890X", + "92369": "AB890X", + "92371": "AB890X", + "92372": "AB890X", + "92373": "AB890X", + "92374": "AB890X", + "92375": "AB890X", + "92376": "AB890X", + "92377": "AB890X", + "92378": "AB890X", + "92382": "AB890X", + "92384": "AB890X", + "92385": "AB890X", + "92386": "AB890X", + "92389": "AB890X", + "92391": "AB890X", + "92392": "AB890X", + "92393": "AB890X", + "92394": "AB890X", + "92395": "AB890X", + "92397": "AB890X", + "92398": "AB890X", + "92399": "AB890X", + "92401": "AB890X", + "92402": "AB890X", + "92403": "AB890X", + "92404": "AB890X", + "92405": "AB890X", + "92406": "AB890X", + "92407": "AB890X", + "92408": "AB890X", + "92410": "AB890X", + "92411": "AB890X", + "92412": "AB890X", + "92413": "AB890X", + "92414": "AB890X", + "92415": "AB890X", + "92418": "AB890X", + "92423": "AB890X", + "92424": "AB890X", + "92427": "AB890X", + "92501": "AB890X", + "92502": "AB890X", + "92503": "AB890X", + "92504": "AB890X", + "92505": "AB890X", + "92506": "AB890X", + "92507": "AB889X", + "92508": "AB890X", + "92509": "AB890X", + "92513": "AB890X", + "92514": "AB890X", + "92515": "AB890X", + "92516": "AB890X", + "92517": "AB890X", + "92518": "AB890X", + "92519": "AB890X", + "92521": "AB890X", + "92522": "AB890X", + "92530": "AB890X", + "92531": "AB890X", + "92532": "AB890X", + "92536": "AB890X", + "92539": "AB890X", + "92543": "AB890X", + "92544": "AB890X", + "92545": "AB890X", + "92546": "AB890X", + "92548": "AB890X", + "92549": "AB890X", + "92551": "AB890X", + "92552": "AB890X", + "92553": "AB890X", + "92554": "AB890X", + "92555": "AB890X", + "92556": "AB890X", + "92557": "AB890X", + "92561": "AB890X", + "92562": "AB890X", + "92563": "AB890X", + "92564": "AB890X", + "92567": "AB890X", + "92570": "AB890X", + "92571": "AB890X", + "92572": "AB890X", + "92581": "AB890X", + "92582": "AB890X", + "92583": "AB890X", + "92584": "AB890X", + "92585": "AB890X", + "92586": "AB890X", + "92587": "AB890X", + "92589": "AB890X", + "92590": "AB890X", + "92591": "AB890X", + "92592": "AB890X", + "92593": "AB890X", + "92595": "AB890X", + "92596": "AB890X", + "92599": "AB890X", + "92602": "AB890X", + "92603": "AB890X", + "92604": "AB890X", + "92605": "AB890X", + "92606": "AB890X", + "92607": "AB890X", + "92609": "AB890X", + "92610": "AB890X", + "92612": "AB890X", + "92614": "AB890X", + "92615": "AB890X", + "92616": "AB890X", + "92617": "AB890X", + "92618": "AB890X", + "92619": "AB890X", + "92620": "AB890X", + "92623": "AB890X", + "92624": "AB890X", + "92625": "AB890X", + "92626": "AB890X", + "92627": "AB890X", + "92628": "AB890X", + "92629": "AB890X", + "92630": "AB890X", + "92637": "AB890X", + "92646": "AB890X", + "92647": "AB890X", + "92648": "AB890X", + "92649": "AB890X", + "92650": "AB890X", + "92651": "AB890X", + "92652": "AB890X", + "92653": "AB890X", + "92654": "AB890X", + "92655": "AB890X", + "92656": "AB890X", + "92657": "AB890X", + "92658": "AB890X", + "92659": "AB890X", + "92660": "AB890X", + "92661": "AB890X", + "92662": "AB890X", + "92663": "AB890X", + "92672": "AB890X", + "92673": "AB890X", + "92674": "AB890X", + "92675": "AB890X", + "92676": "AB890X", + "92677": "AB890X", + "92678": "AB890X", + "92679": "AB890X", + "92683": "AB890X", + "92684": "AB890X", + "92685": "AB890X", + "92688": "AB890X", + "92690": "AB890X", + "92691": "AB890X", + "92692": "AB890X", + "92693": "AB890X", + "92694": "AB890X", + "92697": "AB890X", + "92698": "AB890X", + "92701": "AB890X", + "92702": "AB890X", + "92703": "AB890X", + "92704": "AB890X", + "92705": "AB890X", + "92706": "AB890X", + "92707": "AB890X", + "92708": "AB890X", + "92709": "AB890X", + "92710": "AB890X", + "92711": "AB890X", + "92712": "AB890X", + "92725": "AB890X", + "92728": "AB890X", + "92735": "AB890X", + "92780": "AB890X", + "92781": "AB890X", + "92782": "AB890X", + "92799": "AB890X", + "92801": "AB890X", + "92802": "AB890X", + "92803": "AB890X", + "92804": "AB890X", + "92805": "AB890X", + "92806": "AB890X", + "92807": "AB890X", + "92808": "AB890X", + "92809": "AB890X", + "92811": "AB890X", + "92812": "AB890X", + "92814": "AB890X", + "92815": "AB890X", + "92816": "AB890X", + "92817": "AB890X", + "92821": "AB890X", + "92822": "AB890X", + "92823": "AB890X", + "92825": "AB890X", + "92831": "AB890X", + "92832": "AB890X", + "92833": "AB890X", + "92834": "AB890X", + "92835": "AB890X", + "92836": "AB890X", + "92837": "AB890X", + "92838": "AB890X", + "92840": "AB890X", + "92841": "AB890X", + "92842": "AB890X", + "92843": "AB890X", + "92844": "AB890X", + "92845": "AB890X", + "92846": "AB890X", + "92850": "AB890X", + "92856": "AB890X", + "92857": "AB890X", + "92859": "AB890X", + "92860": "AB890X", + "92861": "AB890X", + "92862": "AB890X", + "92863": "AB890X", + "92864": "AB890X", + "92865": "AB890X", + "92866": "AB890X", + "92867": "AB890X", + "92868": "AB890X", + "92869": "AB890X", + "92870": "AB890X", + "92871": "AB890X", + "92877": "AB890X", + "92878": "AB890X", + "92879": "AB890X", + "92880": "AB890X", + "92881": "AB890X", + "92882": "AB890X", + "92883": "AB890X", + "92885": "AB890X", + "92886": "AB890X", + "92887": "AB890X", + "92899": "AB890X", + "93001": "AB890X", + "93002": "AB890X", + "93003": "AB890X", + "93004": "AB890X", + "93005": "AB890X", + "93006": "AB890X", + "93007": "AB890X", + "93009": "AB890X", + "93010": "AB890X", + "93011": "AB890X", + "93012": "AB890X", + "93013": "AB890X", + "93014": "AB890X", + "93015": "AB890X", + "93016": "AB890X", + "93020": "AB890X", + "93021": "AB890X", + "93022": "AB890X", + "93023": "AB890X", + "93024": "AB890X", + "93030": "AB890X", + "93031": "AB890X", + "93032": "AB890X", + "93033": "AB890X", + "93034": "AB890X", + "93035": "AB890X", + "93036": "AB890X", + "93040": "AB890X", + "93041": "AB890X", + "93042": "AB890X", + "93043": "AB890X", + "93044": "AB890X", + "93060": "AB890X", + "93061": "AB890X", + "93062": "AB890X", + "93063": "AB890X", + "93064": "AB890X", + "93065": "AB890X", + "93066": "AB890X", + "93067": "AB890X", + "93093": "AB890X", + "93094": "AB890X", + "93099": "AB890X", + "93101": "AB890X", + "93102": "AB890X", + "93103": "AB890X", + "93105": "AB890X", + "93106": "AB890X", + "93107": "AB890X", + "93108": "AB890X", + "93109": "AB890X", + "93110": "AB890X", + "93111": "AB890X", + "93116": "AB890X", + "93117": "AB890X", + "93118": "AB890X", + "93120": "AB890X", + "93121": "AB890X", + "93130": "AB890X", + "93140": "AB890X", + "93150": "AB890X", + "93160": "AB890X", + "93190": "AB890X", + "93199": "AB890X", + "93201": "AB887X", + "93202": "AB887X", + "93203": "AB890X", + "93204": "AB887X", + "93205": "AB890X", + "93206": "AB890X", + "93207": "AB887X", + "93208": "AB887X", + "93210": "AB887X", + "93212": "AB887X", + "93215": "AB890X", + "93216": "AB890X", + "93218": "AB887X", + "93219": "AB887X", + "93220": "AB890X", + "93221": "AB887X", + "93222": "AB890X", + "93223": "AB887X", + "93224": "AB890X", + "93225": "AB890X", + "93226": "AB890X", + "93227": "AB887X", + "93230": "AB887X", + "93232": "AB887X", + "93234": "AB887X", + "93235": "AB887X", + "93237": "AB887X", + "93238": "AB890X", + "93239": "AB887X", + "93240": "AB890X", + "93241": "AB890X", + "93242": "AB887X", + "93243": "AB890X", + "93244": "AB887X", + "93245": "AB887X", + "93246": "AB887X", + "93247": "AB887X", + "93249": "AB890X", + "93250": "AB890X", + "93251": "AB890X", + "93252": "AB890X", + "93254": "AB890X", + "93255": "AB890X", + "93256": "AB887X", + "93257": "AB887X", + "93258": "AB887X", + "93260": "AB887X", + "93261": "AB887X", + "93262": "AB887X", + "93263": "AB890X", + "93265": "AB887X", + "93266": "AB887X", + "93267": "AB887X", + "93268": "AB890X", + "93270": "AB887X", + "93271": "AB887X", + "93272": "AB887X", + "93274": "AB887X", + "93275": "AB887X", + "93276": "AB890X", + "93277": "AB887X", + "93278": "AB887X", + "93279": "AB887X", + "93280": "AB890X", + "93282": "AB887X", + "93283": "AB890X", + "93285": "AB890X", + "93286": "AB887X", + "93287": "AB890X", + "93290": "AB887X", + "93291": "AB887X", + "93292": "AB887X", + "93301": "AB890X", + "93302": "AB890X", + "93303": "AB890X", + "93304": "AB890X", + "93305": "AB890X", + "93306": "AB890X", + "93307": "AB890X", + "93308": "AB890X", + "93309": "AB890X", + "93311": "AB890X", + "93312": "AB890X", + "93313": "AB890X", + "93314": "AB890X", + "93380": "AB890X", + "93381": "AB890X", + "93382": "AB890X", + "93383": "AB890X", + "93384": "AB890X", + "93385": "AB890X", + "93386": "AB890X", + "93387": "AB890X", + "93388": "AB890X", + "93389": "AB890X", + "93390": "AB890X", + "93401": "AB890X", + "93402": "AB890X", + "93403": "AB890X", + "93405": "AB890X", + "93406": "AB890X", + "93407": "AB890X", + "93408": "AB890X", + "93409": "AB890X", + "93410": "AB890X", + "93412": "AB890X", + "93420": "AB890X", + "93421": "AB890X", + "93422": "AB890X", + "93423": "AB890X", + "93424": "AB890X", + "93426": "AB887X", + "93427": "AB890X", + "93428": "AB890X", + "93429": "AB890X", + "93430": "AB890X", + "93432": "AB890X", + "93433": "AB890X", + "93434": "AB890X", + "93435": "AB890X", + "93436": "AB890X", + "93437": "AB890X", + "93438": "AB890X", + "93440": "AB890X", + "93441": "AB890X", + "93442": "AB890X", + "93443": "AB890X", + "93444": "AB890X", + "93445": "AB890X", + "93446": "AB890X", + "93447": "AB890X", + "93448": "AB890X", + "93449": "AB890X", + "93450": "AB887X", + "93451": "AB890X", + "93452": "AB890X", + "93453": "AB890X", + "93454": "AB890X", + "93455": "AB890X", + "93456": "AB890X", + "93457": "AB890X", + "93458": "AB890X", + "93460": "AB890X", + "93461": "AB890X", + "93463": "AB890X", + "93464": "AB890X", + "93465": "AB890X", + "93475": "AB890X", + "93483": "AB890X", + "93501": "AB890X", + "93502": "AB890X", + "93504": "AB890X", + "93505": "AB890X", + "93510": "AB890X", + "93512": "AB890X", + "93513": "AB890X", + "93514": "AB890X", + "93515": "AB890X", + "93516": "AB890X", + "93517": "AB890X", + "93518": "AB890X", + "93519": "AB890X", + "93522": "AB890X", + "93523": "AB890X", + "93524": "AB890X", + "93526": "AB890X", + "93527": "AB890X", + "93528": "AB890X", + "93529": "AB890X", + "93530": "AB890X", + "93531": "AB890X", + "93532": "AB890X", + "93534": "AB890X", + "93535": "AB890X", + "93536": "AB890X", + "93539": "AB890X", + "93541": "AB890X", + "93542": "AB890X", + "93543": "AB890X", + "93544": "AB890X", + "93545": "AB890X", + "93546": "AB890X", + "93549": "AB890X", + "93550": "AB890X", + "93551": "AB890X", + "93552": "AB890X", + "93553": "AB890X", + "93554": "AB890X", + "93555": "AB890X", + "93556": "AB890X", + "93558": "AB890X", + "93560": "AB890X", + "93561": "AB890X", + "93562": "AB890X", + "93563": "AB890X", + "93581": "AB890X", + "93584": "AB890X", + "93586": "AB890X", + "93590": "AB890X", + "93591": "AB890X", + "93592": "AB890X", + "93596": "AB890X", + "93599": "AB890X", + "93601": "AB887X", + "93602": "AB887X", + "93603": "AB887X", + "93604": "AB887X", + "93605": "AB887X", + "93606": "AB887X", + "93607": "AB887X", + "93608": "AB887X", + "93609": "AB887X", + "93610": "AB887X", + "93611": "AB887X", + "93612": "AB887X", + "93613": "AB887X", + "93614": "AB887X", + "93615": "AB887X", + "93616": "AB887X", + "93618": "AB887X", + "93619": "AB887X", + "93620": "AB887X", + "93621": "AB887X", + "93622": "AB887X", + "93623": "AB887X", + "93624": "AB887X", + "93625": "AB887X", + "93626": "AB887X", + "93627": "AB887X", + "93628": "AB887X", + "93630": "AB887X", + "93631": "AB887X", + "93633": "AB887X", + "93634": "AB887X", + "93635": "AB887X", + "93636": "AB887X", + "93637": "AB887X", + "93638": "AB887X", + "93639": "AB887X", + "93640": "AB887X", + "93641": "AB887X", + "93642": "AB887X", + "93643": "AB887X", + "93644": "AB887X", + "93645": "AB887X", + "93646": "AB887X", + "93647": "AB887X", + "93648": "AB887X", + "93649": "AB887X", + "93650": "AB887X", + "93651": "AB887X", + "93652": "AB887X", + "93653": "AB887X", + "93654": "AB887X", + "93656": "AB887X", + "93657": "AB887X", + "93660": "AB887X", + "93661": "AB887X", + "93662": "AB887X", + "93664": "AB887X", + "93665": "AB887X", + "93666": "AB887X", + "93667": "AB887X", + "93668": "AB887X", + "93669": "AB887X", + "93670": "AB887X", + "93673": "AB887X", + "93675": "AB887X", + "93701": "AB887X", + "93702": "AB887X", + "93703": "AB887X", + "93704": "AB887X", + "93705": "AB887X", + "93706": "AB887X", + "93707": "AB887X", + "93708": "AB887X", + "93709": "AB887X", + "93710": "AB887X", + "93711": "AB887X", + "93712": "AB887X", + "93714": "AB887X", + "93715": "AB887X", + "93716": "AB887X", + "93717": "AB887X", + "93718": "AB887X", + "93720": "AB887X", + "93721": "AB887X", + "93722": "AB887X", + "93723": "AB887X", + "93724": "AB887X", + "93725": "AB887X", + "93726": "AB887X", + "93727": "AB887X", + "93728": "AB887X", + "93729": "AB887X", + "93730": "AB887X", + "93740": "AB887X", + "93741": "AB887X", + "93744": "AB887X", + "93745": "AB887X", + "93747": "AB887X", + "93750": "AB887X", + "93755": "AB887X", + "93760": "AB887X", + "93761": "AB887X", + "93764": "AB887X", + "93765": "AB887X", + "93771": "AB887X", + "93772": "AB887X", + "93773": "AB887X", + "93774": "AB887X", + "93775": "AB887X", + "93776": "AB887X", + "93777": "AB887X", + "93778": "AB887X", + "93779": "AB887X", + "93780": "AB887X", + "93784": "AB887X", + "93786": "AB887X", + "93790": "AB887X", + "93791": "AB887X", + "93792": "AB887X", + "93793": "AB887X", + "93794": "AB887X", + "93844": "AB887X", + "93888": "AB887X", + "93901": "AB887X", + "93902": "AB887X", + "93905": "AB887X", + "93906": "AB887X", + "93907": "AB887X", + "93908": "AB887X", + "93912": "AB887X", + "93915": "AB887X", + "93920": "AB887X", + "93921": "AB887X", + "93922": "AB887X", + "93923": "AB887X", + "93924": "AB887X", + "93925": "AB887X", + "93926": "AB887X", + "93927": "AB887X", + "93928": "AB887X", + "93930": "AB887X", + "93932": "AB887X", + "93933": "AB887X", + "93940": "AB887X", + "93942": "AB887X", + "93943": "AB887X", + "93944": "AB887X", + "93950": "AB887X", + "93953": "AB887X", + "93954": "AB887X", + "93955": "AB887X", + "93960": "AB887X", + "93962": "AB887X", + "94002": "AB887X", + "94005": "AB887X", + "94010": "AB887X", + "94011": "AB887X", + "94013": "AB887X", + "94014": "AB887X", + "94015": "AB887X", + "94016": "AB887X", + "94017": "AB887X", + "94018": "AB887X", + "94019": "AB887X", + "94020": "AB887X", + "94021": "AB887X", + "94022": "AB887X", + "94023": "AB887X", + "94024": "AB887X", + "94025": "AB887X", + "94026": "AB887X", + "94027": "AB887X", + "94028": "AB887X", + "94030": "AB887X", + "94035": "AB887X", + "94037": "AB887X", + "94038": "AB887X", + "94039": "AB887X", + "94040": "AB887X", + "94041": "AB887X", + "94042": "AB887X", + "94043": "AB887X", + "94044": "AB887X", + "94060": "AB887X", + "94061": "AB887X", + "94062": "AB887X", + "94063": "AB887X", + "94064": "AB887X", + "94065": "AB887X", + "94066": "AB887X", + "94070": "AB887X", + "94074": "AB887X", + "94080": "AB887X", + "94083": "AB887X", + "94085": "AB887X", + "94086": "AB887X", + "94087": "AB887X", + "94088": "AB887X", + "94089": "AB887X", + "94096": "AB887X", + "94098": "AB887X", + "94101": "AB887X", + "94102": "AB887X", + "94103": "AB887X", + "94104": "AB887X", + "94105": "AB887X", + "94106": "AB887X", + "94107": "AB887X", + "94108": "AB887X", + "94109": "AB887X", + "94110": "AB887X", + "94111": "AB887X", + "94112": "AB887X", + "94114": "AB887X", + "94115": "AB887X", + "94116": "AB887X", + "94117": "AB887X", + "94118": "AB887X", + "94119": "AB887X", + "94120": "AB887X", + "94121": "AB887X", + "94122": "AB887X", + "94123": "AB887X", + "94124": "AB887X", + "94125": "AB887X", + "94126": "AB887X", + "94127": "AB887X", + "94128": "AB887X", + "94129": "AB887X", + "94130": "AB887X", + "94131": "AB887X", + "94132": "AB887X", + "94133": "AB887X", + "94134": "AB887X", + "94135": "AB887X", + "94136": "AB887X", + "94137": "AB887X", + "94138": "AB887X", + "94139": "AB887X", + "94140": "AB887X", + "94141": "AB887X", + "94142": "AB887X", + "94143": "AB887X", + "94144": "AB887X", + "94145": "AB887X", + "94146": "AB887X", + "94147": "AB887X", + "94150": "AB887X", + "94151": "AB887X", + "94152": "AB887X", + "94153": "AB887X", + "94154": "AB887X", + "94155": "AB887X", + "94156": "AB887X", + "94157": "AB887X", + "94158": "AB887X", + "94159": "AB887X", + "94160": "AB887X", + "94161": "AB887X", + "94162": "AB887X", + "94163": "AB887X", + "94164": "AB887X", + "94165": "AB887X", + "94166": "AB887X", + "94167": "AB887X", + "94168": "AB887X", + "94169": "AB887X", + "94170": "AB887X", + "94171": "AB887X", + "94172": "AB887X", + "94175": "AB887X", + "94177": "AB887X", + "94188": "AB887X", + "94199": "AB887X", + "94203": "AB887X", + "94204": "AB887X", + "94205": "AB887X", + "94206": "AB887X", + "94207": "AB887X", + "94208": "AB887X", + "94209": "AB887X", + "94211": "AB887X", + "94229": "AB887X", + "94230": "AB887X", + "94232": "AB887X", + "94234": "AB887X", + "94235": "AB887X", + "94236": "AB887X", + "94237": "AB887X", + "94239": "AB887X", + "94240": "AB887X", + "94244": "AB887X", + "94245": "AB887X", + "94246": "AB887X", + "94247": "AB887X", + "94248": "AB887X", + "94249": "AB887X", + "94250": "AB887X", + "94252": "AB887X", + "94254": "AB887X", + "94256": "AB887X", + "94257": "AB887X", + "94258": "AB887X", + "94259": "AB887X", + "94261": "AB887X", + "94262": "AB887X", + "94263": "AB887X", + "94267": "AB887X", + "94268": "AB887X", + "94269": "AB887X", + "94271": "AB887X", + "94273": "AB887X", + "94274": "AB887X", + "94277": "AB887X", + "94278": "AB887X", + "94279": "AB887X", + "94280": "AB887X", + "94282": "AB887X", + "94283": "AB887X", + "94284": "AB887X", + "94285": "AB887X", + "94286": "AB887X", + "94287": "AB887X", + "94288": "AB887X", + "94289": "AB887X", + "94290": "AB887X", + "94291": "AB887X", + "94293": "AB887X", + "94294": "AB887X", + "94295": "AB887X", + "94296": "AB887X", + "94297": "AB887X", + "94298": "AB887X", + "94299": "AB887X", + "94301": "AB887X", + "94302": "AB887X", + "94303": "AB887X", + "94304": "AB887X", + "94305": "AB887X", + "94306": "AB887X", + "94309": "AB887X", + "94401": "AB887X", + "94402": "AB887X", + "94403": "AB887X", + "94404": "AB887X", + "94497": "AB887X", + "94501": "AB887X", + "94502": "AB887X", + "94503": "AB887X", + "94506": "AB887X", + "94507": "AB887X", + "94508": "AB887X", + "94509": "AB887X", + "94510": "AB887X", + "94511": "AB887X", + "94512": "AB887X", + "94513": "AB887X", + "94514": "AB887X", + "94515": "AB887X", + "94516": "AB887X", + "94517": "AB887X", + "94518": "AB887X", + "94519": "AB887X", + "94520": "AB887X", + "94521": "AB887X", + "94522": "AB887X", + "94523": "AB887X", + "94524": "AB887X", + "94525": "AB887X", + "94526": "AB887X", + "94527": "AB887X", + "94528": "AB887X", + "94529": "AB887X", + "94530": "AB887X", + "94531": "AB887X", + "94533": "AB887X", + "94534": "AB887X", + "94535": "AB887X", + "94536": "AB887X", + "94537": "AB887X", + "94538": "AB887X", + "94539": "AB887X", + "94540": "AB887X", + "94541": "AB887X", + "94542": "AB887X", + "94543": "AB887X", + "94544": "AB887X", + "94545": "AB887X", + "94546": "AB887X", + "94547": "AB887X", + "94548": "AB887X", + "94549": "AB887X", + "94550": "AB887X", + "94551": "AB887X", + "94552": "AB887X", + "94553": "AB887X", + "94555": "AB887X", + "94556": "AB887X", + "94557": "AB887X", + "94558": "AB887X", + "94559": "AB887X", + "94560": "AB887X", + "94561": "AB887X", + "94562": "AB887X", + "94563": "AB887X", + "94564": "AB887X", + "94565": "AB887X", + "94566": "AB887X", + "94567": "AB887X", + "94568": "AB887X", + "94569": "AB887X", + "94570": "AB887X", + "94571": "AB887X", + "94572": "AB887X", + "94573": "AB887X", + "94574": "AB887X", + "94575": "AB887X", + "94576": "AB887X", + "94577": "AB887X", + "94578": "AB887X", + "94579": "AB887X", + "94580": "AB887X", + "94581": "AB887X", + "94582": "AB887X", + "94583": "AB887X", + "94585": "AB887X", + "94586": "AB887X", + "94587": "AB887X", + "94588": "AB887X", + "94589": "AB887X", + "94590": "AB887X", + "94591": "AB887X", + "94592": "AB887X", + "94595": "AB887X", + "94596": "AB887X", + "94597": "AB887X", + "94598": "AB887X", + "94599": "AB887X", + "94601": "AB887X", + "94602": "AB887X", + "94603": "AB887X", + "94604": "AB887X", + "94605": "AB887X", + "94606": "AB887X", + "94607": "AB887X", + "94608": "AB887X", + "94609": "AB887X", + "94610": "AB887X", + "94611": "AB887X", + "94612": "AB887X", + "94613": "AB887X", + "94614": "AB887X", + "94615": "AB887X", + "94617": "AB887X", + "94618": "AB887X", + "94619": "AB887X", + "94620": "AB887X", + "94621": "AB887X", + "94622": "AB887X", + "94623": "AB887X", + "94624": "AB887X", + "94625": "AB887X", + "94649": "AB887X", + "94659": "AB887X", + "94660": "AB887X", + "94661": "AB887X", + "94662": "AB887X", + "94666": "AB887X", + "94701": "AB887X", + "94702": "AB887X", + "94703": "AB887X", + "94704": "AB887X", + "94705": "AB887X", + "94706": "AB887X", + "94707": "AB887X", + "94708": "AB887X", + "94709": "AB887X", + "94710": "AB887X", + "94712": "AB887X", + "94720": "AB887X", + "94801": "AB887X", + "94802": "AB887X", + "94803": "AB887X", + "94804": "AB887X", + "94805": "AB887X", + "94806": "AB887X", + "94807": "AB887X", + "94808": "AB887X", + "94820": "AB887X", + "94850": "AB887X", + "94901": "AB887X", + "94903": "AB887X", + "94904": "AB887X", + "94912": "AB887X", + "94913": "AB887X", + "94914": "AB887X", + "94915": "AB887X", + "94920": "AB887X", + "94922": "AB887X", + "94923": "AB887X", + "94924": "AB887X", + "94925": "AB887X", + "94926": "AB887X", + "94927": "AB887X", + "94928": "AB887X", + "94929": "AB887X", + "94930": "AB887X", + "94931": "AB887X", + "94933": "AB887X", + "94937": "AB887X", + "94938": "AB887X", + "94939": "AB887X", + "94940": "AB887X", + "94941": "AB887X", + "94942": "AB887X", + "94945": "AB887X", + "94946": "AB887X", + "94947": "AB887X", + "94948": "AB887X", + "94949": "AB887X", + "94950": "AB887X", + "94951": "AB887X", + "94952": "AB887X", + "94953": "AB887X", + "94954": "AB887X", + "94955": "AB887X", + "94956": "AB887X", + "94957": "AB887X", + "94960": "AB887X", + "94963": "AB887X", + "94964": "AB887X", + "94965": "AB887X", + "94966": "AB887X", + "94970": "AB887X", + "94971": "AB887X", + "94972": "AB887X", + "94973": "AB887X", + "94974": "AB887X", + "94975": "AB887X", + "94976": "AB887X", + "94977": "AB887X", + "94978": "AB887X", + "94979": "AB887X", + "94998": "AB887X", + "94999": "AB887X", + "95001": "AB887X", + "95002": "AB887X", + "95003": "AB887X", + "95004": "AB887X", + "95005": "AB887X", + "95006": "AB887X", + "95007": "AB887X", + "95008": "AB887X", + "95009": "AB887X", + "95010": "AB887X", + "95011": "AB887X", + "95012": "AB887X", + "95013": "AB887X", + "95014": "AB887X", + "95015": "AB887X", + "95017": "AB887X", + "95018": "AB887X", + "95019": "AB887X", + "95020": "AB887X", + "95021": "AB887X", + "95023": "AB887X", + "95024": "AB887X", + "95026": "AB887X", + "95030": "AB887X", + "95031": "AB887X", + "95032": "AB887X", + "95033": "AB887X", + "95035": "AB887X", + "95036": "AB887X", + "95037": "AB887X", + "95038": "AB887X", + "95039": "AB887X", + "95041": "AB887X", + "95042": "AB887X", + "95043": "AB887X", + "95044": "AB887X", + "95045": "AB887X", + "95046": "AB887X", + "95050": "AB887X", + "95051": "AB887X", + "95052": "AB887X", + "95053": "AB887X", + "95054": "AB887X", + "95055": "AB887X", + "95056": "AB887X", + "95060": "AB887X", + "95061": "AB887X", + "95062": "AB887X", + "95063": "AB887X", + "95064": "AB887X", + "95065": "AB887X", + "95066": "AB887X", + "95067": "AB887X", + "95070": "AB887X", + "95071": "AB887X", + "95073": "AB887X", + "95075": "AB887X", + "95076": "AB887X", + "95077": "AB887X", + "95101": "AB887X", + "95103": "AB887X", + "95106": "AB887X", + "95108": "AB887X", + "95109": "AB887X", + "95110": "AB887X", + "95111": "AB887X", + "95112": "AB887X", + "95113": "AB887X", + "95115": "AB887X", + "95116": "AB887X", + "95117": "AB887X", + "95118": "AB887X", + "95119": "AB887X", + "95120": "AB887X", + "95121": "AB887X", + "95122": "AB887X", + "95123": "AB887X", + "95124": "AB887X", + "95125": "AB887X", + "95126": "AB887X", + "95127": "AB887X", + "95128": "AB887X", + "95129": "AB887X", + "95130": "AB887X", + "95131": "AB887X", + "95132": "AB887X", + "95133": "AB887X", + "95134": "AB887X", + "95135": "AB887X", + "95136": "AB887X", + "95138": "AB887X", + "95139": "AB887X", + "95140": "AB887X", + "95141": "AB887X", + "95148": "AB887X", + "95150": "AB887X", + "95151": "AB887X", + "95152": "AB887X", + "95153": "AB887X", + "95154": "AB887X", + "95155": "AB887X", + "95156": "AB887X", + "95157": "AB887X", + "95158": "AB887X", + "95159": "AB887X", + "95160": "AB887X", + "95161": "AB887X", + "95164": "AB887X", + "95170": "AB887X", + "95172": "AB887X", + "95173": "AB887X", + "95190": "AB887X", + "95191": "AB887X", + "95192": "AB887X", + "95193": "AB887X", + "95194": "AB887X", + "95196": "AB887X", + "95201": "AB887X", + "95202": "AB887X", + "95203": "AB887X", + "95204": "AB887X", + "95205": "AB887X", + "95206": "AB887X", + "95207": "AB887X", + "95208": "AB887X", + "95209": "AB887X", + "95210": "AB887X", + "95211": "AB887X", + "95212": "AB887X", + "95213": "AB887X", + "95215": "AB887X", + "95219": "AB887X", + "95220": "AB887X", + "95221": "AB887X", + "95222": "AB887X", + "95223": "AB887X", + "95224": "AB887X", + "95225": "AB887X", + "95226": "AB887X", + "95227": "AB887X", + "95228": "AB887X", + "95229": "AB887X", + "95230": "AB887X", + "95231": "AB887X", + "95232": "AB887X", + "95233": "AB887X", + "95234": "AB887X", + "95236": "AB887X", + "95237": "AB887X", + "95240": "AB887X", + "95241": "AB887X", + "95242": "AB887X", + "95245": "AB887X", + "95246": "AB887X", + "95247": "AB887X", + "95248": "AB887X", + "95249": "AB887X", + "95250": "AB887X", + "95251": "AB887X", + "95252": "AB887X", + "95253": "AB887X", + "95254": "AB887X", + "95255": "AB887X", + "95257": "AB887X", + "95258": "AB887X", + "95267": "AB887X", + "95269": "AB887X", + "95296": "AB887X", + "95297": "AB887X", + "95301": "AB887X", + "95303": "AB887X", + "95304": "AB887X", + "95305": "AB887X", + "95306": "AB887X", + "95307": "AB887X", + "95309": "AB887X", + "95310": "AB887X", + "95311": "AB887X", + "95312": "AB887X", + "95313": "AB887X", + "95314": "AB887X", + "95315": "AB887X", + "95316": "AB887X", + "95317": "AB887X", + "95318": "AB887X", + "95319": "AB887X", + "95320": "AB887X", + "95321": "AB887X", + "95322": "AB887X", + "95323": "AB887X", + "95324": "AB887X", + "95325": "AB887X", + "95326": "AB887X", + "95327": "AB887X", + "95328": "AB887X", + "95329": "AB887X", + "95330": "AB887X", + "95333": "AB887X", + "95334": "AB887X", + "95335": "AB887X", + "95336": "AB887X", + "95337": "AB887X", + "95338": "AB887X", + "95340": "AB887X", + "95341": "AB887X", + "95343": "AB887X", + "95344": "AB887X", + "95345": "AB887X", + "95346": "AB887X", + "95347": "AB887X", + "95348": "AB887X", + "95350": "AB887X", + "95351": "AB887X", + "95352": "AB887X", + "95353": "AB887X", + "95354": "AB887X", + "95355": "AB887X", + "95356": "AB887X", + "95357": "AB887X", + "95358": "AB887X", + "95360": "AB887X", + "95361": "AB887X", + "95363": "AB887X", + "95364": "AB887X", + "95365": "AB887X", + "95366": "AB887X", + "95367": "AB887X", + "95368": "AB887X", + "95369": "AB887X", + "95370": "AB887X", + "95372": "AB887X", + "95373": "AB887X", + "95374": "AB887X", + "95375": "AB887X", + "95376": "AB887X", + "95377": "AB887X", + "95378": "AB887X", + "95379": "AB887X", + "95380": "AB887X", + "95381": "AB887X", + "95382": "AB887X", + "95383": "AB887X", + "95385": "AB887X", + "95386": "AB887X", + "95387": "AB887X", + "95388": "AB887X", + "95389": "AB887X", + "95391": "AB887X", + "95397": "AB887X", + "95401": "AB887X", + "95402": "AB887X", + "95403": "AB887X", + "95404": "AB887X", + "95405": "AB887X", + "95406": "AB887X", + "95407": "AB887X", + "95408": "AB887X", + "95409": "AB887X", + "95410": "AB887X", + "95412": "AB887X", + "95415": "AB887X", + "95416": "AB887X", + "95417": "AB887X", + "95418": "AB887X", + "95419": "AB887X", + "95420": "AB887X", + "95421": "AB887X", + "95422": "AB887X", + "95423": "AB887X", + "95424": "AB887X", + "95425": "AB887X", + "95426": "AB887X", + "95427": "AB887X", + "95428": "AB887X", + "95429": "AB887X", + "95430": "AB887X", + "95431": "AB887X", + "95432": "AB887X", + "95433": "AB887X", + "95435": "AB887X", + "95436": "AB887X", + "95437": "AB887X", + "95439": "AB887X", + "95441": "AB887X", + "95442": "AB887X", + "95443": "AB887X", + "95444": "AB887X", + "95445": "AB887X", + "95446": "AB887X", + "95448": "AB887X", + "95449": "AB887X", + "95450": "AB887X", + "95451": "AB887X", + "95452": "AB887X", + "95453": "AB887X", + "95454": "AB887X", + "95456": "AB887X", + "95457": "AB887X", + "95458": "AB887X", + "95459": "AB887X", + "95460": "AB887X", + "95461": "AB887X", + "95462": "AB887X", + "95463": "AB887X", + "95464": "AB887X", + "95465": "AB887X", + "95466": "AB887X", + "95467": "AB887X", + "95468": "AB887X", + "95469": "AB887X", + "95470": "AB887X", + "95471": "AB887X", + "95472": "AB887X", + "95473": "AB887X", + "95476": "AB887X", + "95480": "AB887X", + "95481": "AB887X", + "95482": "AB887X", + "95485": "AB887X", + "95486": "AB887X", + "95487": "AB887X", + "95488": "AB887X", + "95490": "AB887X", + "95492": "AB887X", + "95493": "AB887X", + "95494": "AB887X", + "95497": "AB887X", + "95501": "AB890X", + "95502": "AB890X", + "95503": "AB890X", + "95511": "AB890X", + "95514": "AB890X", + "95518": "AB890X", + "95519": "AB890X", + "95521": "AB890X", + "95524": "AB890X", + "95525": "AB890X", + "95526": "AB890X", + "95527": "AB890X", + "95528": "AB890X", + "95531": "AB890X", + "95532": "AB890X", + "95534": "AB890X", + "95536": "AB890X", + "95537": "AB890X", + "95538": "AB890X", + "95540": "AB890X", + "95542": "AB890X", + "95543": "AB890X", + "95545": "AB890X", + "95546": "AB890X", + "95547": "AB890X", + "95548": "AB890X", + "95549": "AB890X", + "95550": "AB890X", + "95551": "AB890X", + "95552": "AB890X", + "95553": "AB890X", + "95554": "AB890X", + "95555": "AB890X", + "95556": "AB890X", + "95558": "AB890X", + "95559": "AB890X", + "95560": "AB890X", + "95562": "AB890X", + "95563": "AB890X", + "95564": "AB890X", + "95565": "AB890X", + "95567": "AB890X", + "95568": "AB890X", + "95569": "AB890X", + "95570": "AB890X", + "95571": "AB890X", + "95573": "AB890X", + "95585": "AB887X", + "95587": "AB887X", + "95589": "AB890X", + "95595": "AB890X", + "95601": "AB887X", + "95602": "AB887X", + "95603": "AB887X", + "95604": "AB887X", + "95605": "AB887X", + "95606": "AB887X", + "95607": "AB887X", + "95608": "AB887X", + "95609": "AB887X", + "95610": "AB887X", + "95611": "AB887X", + "95612": "AB887X", + "95613": "AB887X", + "95614": "AB887X", + "95615": "AB887X", + "95616": "AB887X", + "95617": "AB887X", + "95618": "AB887X", + "95619": "AB887X", + "95620": "AB887X", + "95621": "AB887X", + "95623": "AB887X", + "95624": "AB887X", + "95625": "AB887X", + "95626": "AB887X", + "95627": "AB887X", + "95628": "AB887X", + "95629": "AB887X", + "95630": "AB887X", + "95631": "AB887X", + "95632": "AB887X", + "95633": "AB887X", + "95634": "AB887X", + "95635": "AB887X", + "95636": "AB887X", + "95637": "AB887X", + "95638": "AB887X", + "95639": "AB887X", + "95640": "AB887X", + "95641": "AB887X", + "95642": "AB887X", + "95644": "AB887X", + "95645": "AB887X", + "95646": "AB887X", + "95648": "AB887X", + "95650": "AB887X", + "95651": "AB887X", + "95652": "AB887X", + "95653": "AB887X", + "95654": "AB887X", + "95655": "AB887X", + "95656": "AB887X", + "95658": "AB887X", + "95659": "AB887X", + "95660": "AB887X", + "95661": "AB887X", + "95662": "AB887X", + "95663": "AB887X", + "95664": "AB887X", + "95665": "AB887X", + "95666": "AB887X", + "95667": "AB887X", + "95668": "AB887X", + "95669": "AB887X", + "95670": "AB887X", + "95671": "AB887X", + "95672": "AB887X", + "95673": "AB887X", + "95674": "AB887X", + "95675": "AB887X", + "95676": "AB887X", + "95677": "AB887X", + "95678": "AB887X", + "95679": "AB887X", + "95680": "AB887X", + "95681": "AB887X", + "95682": "AB887X", + "95683": "AB887X", + "95684": "AB887X", + "95685": "AB887X", + "95686": "AB887X", + "95687": "AB887X", + "95688": "AB887X", + "95689": "AB887X", + "95690": "AB887X", + "95691": "AB887X", + "95692": "AB887X", + "95693": "AB887X", + "95694": "AB887X", + "95695": "AB887X", + "95696": "AB887X", + "95697": "AB887X", + "95698": "AB887X", + "95699": "AB887X", + "95701": "AB887X", + "95703": "AB887X", + "95709": "AB887X", + "95712": "AB887X", + "95713": "AB887X", + "95714": "AB887X", + "95715": "AB887X", + "95717": "AB887X", + "95720": "AB887X", + "95721": "AB887X", + "95722": "AB887X", + "95724": "AB887X", + "95726": "AB887X", + "95728": "AB887X", + "95735": "AB887X", + "95736": "AB887X", + "95741": "AB887X", + "95742": "AB887X", + "95746": "AB887X", + "95747": "AB887X", + "95757": "AB887X", + "95758": "AB887X", + "95759": "AB887X", + "95762": "AB887X", + "95763": "AB887X", + "95765": "AB887X", + "95776": "AB887X", + "95798": "AB887X", + "95799": "AB887X", + "95812": "AB887X", + "95813": "AB887X", + "95814": "AB887X", + "95815": "AB887X", + "95816": "AB887X", + "95817": "AB887X", + "95818": "AB887X", + "95819": "AB887X", + "95820": "AB887X", + "95821": "AB887X", + "95822": "AB887X", + "95823": "AB887X", + "95824": "AB887X", + "95825": "AB887X", + "95826": "AB887X", + "95827": "AB887X", + "95828": "AB887X", + "95829": "AB887X", + "95830": "AB887X", + "95831": "AB887X", + "95832": "AB887X", + "95833": "AB887X", + "95834": "AB887X", + "95835": "AB887X", + "95836": "AB887X", + "95837": "AB887X", + "95838": "AB887X", + "95840": "AB887X", + "95841": "AB887X", + "95842": "AB887X", + "95843": "AB887X", + "95851": "AB887X", + "95852": "AB887X", + "95853": "AB887X", + "95860": "AB887X", + "95864": "AB887X", + "95865": "AB887X", + "95866": "AB887X", + "95867": "AB887X", + "95887": "AB887X", + "95894": "AB887X", + "95899": "AB887X", + "95901": "AB887X", + "95903": "AB887X", + "95910": "AB887X", + "95912": "AB887X", + "95913": "AB887X", + "95914": "AB887X", + "95915": "AB887X", + "95916": "AB887X", + "95917": "AB887X", + "95918": "AB887X", + "95919": "AB887X", + "95920": "AB887X", + "95922": "AB887X", + "95923": "AB887X", + "95924": "AB887X", + "95925": "AB887X", + "95926": "AB887X", + "95927": "AB887X", + "95928": "AB887X", + "95929": "AB887X", + "95930": "AB887X", + "95932": "AB887X", + "95934": "AB887X", + "95935": "AB887X", + "95936": "AB887X", + "95937": "AB887X", + "95938": "AB887X", + "95939": "AB887X", + "95940": "AB887X", + "95941": "AB887X", + "95942": "AB887X", + "95943": "AB887X", + "95944": "AB887X", + "95945": "AB887X", + "95946": "AB887X", + "95947": "AB887X", + "95948": "AB887X", + "95949": "AB887X", + "95950": "AB887X", + "95951": "AB887X", + "95953": "AB887X", + "95954": "AB887X", + "95955": "AB887X", + "95956": "AB887X", + "95957": "AB887X", + "95958": "AB887X", + "95959": "AB887X", + "95960": "AB887X", + "95961": "AB887X", + "95962": "AB887X", + "95963": "AB887X", + "95965": "AB887X", + "95966": "AB887X", + "95967": "AB887X", + "95968": "AB887X", + "95969": "AB887X", + "95970": "AB887X", + "95971": "AB887X", + "95972": "AB887X", + "95973": "AB887X", + "95974": "AB887X", + "95975": "AB887X", + "95976": "AB887X", + "95977": "AB887X", + "95978": "AB887X", + "95979": "AB887X", + "95980": "AB887X", + "95981": "AB887X", + "95982": "AB887X", + "95983": "AB887X", + "95984": "AB887X", + "95986": "AB887X", + "95987": "AB887X", + "95988": "AB887X", + "95991": "AB887X", + "95992": "AB887X", + "95993": "AB887X", + "96001": "AB887X", + "96002": "AB887X", + "96003": "AB887X", + "96006": "AB890X", + "96007": "AB887X", + "96008": "AB887X", + "96009": "AB887X", + "96010": "AB890X", + "96011": "AB887X", + "96013": "AB887X", + "96014": "AB890X", + "96015": "AB890X", + "96016": "AB887X", + "96017": "AB887X", + "96019": "AB887X", + "96020": "AB887X", + "96021": "AB887X", + "96022": "AB887X", + "96023": "AB890X", + "96024": "AB890X", + "96025": "AB890X", + "96027": "AB890X", + "96028": "AB887X", + "96029": "AB887X", + "96031": "AB890X", + "96032": "AB890X", + "96033": "AB887X", + "96034": "AB890X", + "96035": "AB887X", + "96037": "AB890X", + "96038": "AB890X", + "96039": "AB890X", + "96040": "AB887X", + "96041": "AB890X", + "96044": "AB890X", + "96046": "AB890X", + "96047": "AB887X", + "96048": "AB890X", + "96049": "AB887X", + "96050": "AB890X", + "96051": "AB887X", + "96052": "AB890X", + "96054": "AB890X", + "96055": "AB887X", + "96056": "AB887X", + "96057": "AB890X", + "96058": "AB890X", + "96059": "AB887X", + "96061": "AB887X", + "96062": "AB887X", + "96063": "AB887X", + "96064": "AB890X", + "96065": "AB887X", + "96067": "AB890X", + "96068": "AB887X", + "96069": "AB887X", + "96070": "AB887X", + "96071": "AB887X", + "96073": "AB887X", + "96074": "AB887X", + "96075": "AB887X", + "96076": "AB887X", + "96078": "AB887X", + "96079": "AB887X", + "96080": "AB887X", + "96084": "AB887X", + "96085": "AB890X", + "96086": "AB890X", + "96087": "AB887X", + "96088": "AB887X", + "96089": "AB887X", + "96090": "AB887X", + "96091": "AB890X", + "96092": "AB887X", + "96093": "AB890X", + "96094": "AB890X", + "96095": "AB887X", + "96096": "AB887X", + "96097": "AB890X", + "96099": "AB887X", + "96101": "AB890X", + "96103": "AB887X", + "96104": "AB890X", + "96105": "AB887X", + "96106": "AB887X", + "96107": "AB890X", + "96108": "AB890X", + "96109": "AB887X", + "96110": "AB890X", + "96111": "AB887X", + "96112": "AB890X", + "96113": "AB887X", + "96114": "AB887X", + "96115": "AB890X", + "96116": "AB890X", + "96117": "AB887X", + "96118": "AB887X", + "96119": "AB887X", + "96120": "AB887X", + "96121": "AB887X", + "96122": "AB887X", + "96123": "AB887X", + "96124": "AB887X", + "96125": "AB887X", + "96126": "AB887X", + "96127": "AB887X", + "96128": "AB887X", + "96129": "AB887X", + "96130": "AB887X", + "96132": "AB887X", + "96133": "AB890X", + "96134": "AB890X", + "96135": "AB887X", + "96136": "AB887X", + "96137": "AB887X", + "96140": "AB887X", + "96141": "AB887X", + "96142": "AB887X", + "96143": "AB887X", + "96145": "AB887X", + "96146": "AB887X", + "96148": "AB887X", + "96150": "AB887X", + "96151": "AB887X", + "96152": "AB887X", + "96154": "AB887X", + "96155": "AB887X", + "96156": "AB887X", + "96157": "AB887X", + "96158": "AB887X", + "96160": "AB887X", + "96161": "AB887X", + "96162": "AB887X", + "97001": "AB890X", + "97002": "AB890X", + "97004": "AB890X", + "97005": "AB890X", + "97006": "AB890X", + "97007": "AB890X", + "97008": "AB890X", + "97009": "AB890X", + "97010": "AB890X", + "97011": "AB890X", + "97013": "AB890X", + "97014": "AB890X", + "97015": "AB890X", + "97016": "AB890X", + "97017": "AB890X", + "97018": "AB890X", + "97019": "AB890X", + "97020": "AB890X", + "97021": "AB890X", + "97022": "AB890X", + "97023": "AB890X", + "97024": "AB890X", + "97026": "AB890X", + "97027": "AB890X", + "97028": "AB890X", + "97029": "AB890X", + "97030": "AB890X", + "97031": "AB890X", + "97032": "AB890X", + "97033": "AB890X", + "97034": "AB890X", + "97035": "AB890X", + "97036": "AB890X", + "97037": "AB890X", + "97038": "AB890X", + "97039": "AB890X", + "97040": "AB890X", + "97041": "AB890X", + "97042": "AB890X", + "97044": "AB890X", + "97045": "AB890X", + "97048": "AB890X", + "97049": "AB890X", + "97050": "AB890X", + "97051": "AB890X", + "97053": "AB890X", + "97054": "AB890X", + "97055": "AB890X", + "97056": "AB890X", + "97057": "AB890X", + "97058": "AB890X", + "97060": "AB890X", + "97062": "AB890X", + "97063": "AB890X", + "97064": "AB890X", + "97065": "AB890X", + "97067": "AB890X", + "97068": "AB890X", + "97070": "AB890X", + "97071": "AB890X", + "97075": "AB890X", + "97076": "AB890X", + "97077": "AB890X", + "97078": "AB890X", + "97080": "AB890X", + "97086": "AB890X", + "97089": "AB890X", + "97101": "AB890X", + "97102": "AB890X", + "97103": "AB890X", + "97106": "AB890X", + "97107": "AB890X", + "97108": "AB890X", + "97109": "AB890X", + "97110": "AB890X", + "97111": "AB890X", + "97112": "AB890X", + "97113": "AB890X", + "97114": "AB890X", + "97115": "AB890X", + "97116": "AB890X", + "97117": "AB890X", + "97118": "AB890X", + "97119": "AB890X", + "97121": "AB890X", + "97122": "AB890X", + "97123": "AB890X", + "97124": "AB890X", + "97125": "AB890X", + "97127": "AB890X", + "97128": "AB890X", + "97130": "AB890X", + "97131": "AB890X", + "97132": "AB890X", + "97133": "AB890X", + "97134": "AB890X", + "97135": "AB890X", + "97136": "AB890X", + "97137": "AB890X", + "97138": "AB890X", + "97140": "AB890X", + "97141": "AB890X", + "97143": "AB890X", + "97144": "AB890X", + "97145": "AB890X", + "97146": "AB890X", + "97147": "AB890X", + "97148": "AB890X", + "97149": "AB890X", + "97201": "AB890X", + "97202": "AB890X", + "97203": "AB890X", + "97204": "AB890X", + "97205": "AB890X", + "97206": "AB890X", + "97207": "AB890X", + "97208": "AB890X", + "97209": "AB890X", + "97210": "AB890X", + "97211": "AB890X", + "97212": "AB890X", + "97213": "AB890X", + "97214": "AB890X", + "97215": "AB890X", + "97216": "AB890X", + "97217": "AB890X", + "97218": "AB890X", + "97219": "AB890X", + "97220": "AB890X", + "97221": "AB890X", + "97222": "AB890X", + "97223": "AB890X", + "97224": "AB890X", + "97225": "AB890X", + "97227": "AB890X", + "97228": "AB890X", + "97229": "AB890X", + "97230": "AB890X", + "97231": "AB890X", + "97232": "AB890X", + "97233": "AB890X", + "97236": "AB890X", + "97238": "AB890X", + "97239": "AB890X", + "97240": "AB890X", + "97242": "AB890X", + "97251": "AB890X", + "97253": "AB890X", + "97254": "AB890X", + "97255": "AB890X", + "97256": "AB890X", + "97258": "AB890X", + "97259": "AB890X", + "97266": "AB890X", + "97267": "AB890X", + "97268": "AB890X", + "97269": "AB890X", + "97271": "AB890X", + "97272": "AB890X", + "97280": "AB890X", + "97281": "AB890X", + "97282": "AB890X", + "97283": "AB890X", + "97286": "AB890X", + "97290": "AB890X", + "97291": "AB890X", + "97292": "AB890X", + "97293": "AB890X", + "97294": "AB890X", + "97296": "AB890X", + "97298": "AB890X", + "97299": "AB890X", + "97301": "AB890X", + "97302": "AB890X", + "97303": "AB890X", + "97304": "AB890X", + "97305": "AB890X", + "97306": "AB890X", + "97307": "AB890X", + "97308": "AB890X", + "97309": "AB890X", + "97310": "AB890X", + "97311": "AB890X", + "97312": "AB890X", + "97313": "AB890X", + "97314": "AB890X", + "97317": "AB890X", + "97321": "AB890X", + "97322": "AB890X", + "97324": "AB890X", + "97325": "AB890X", + "97326": "AB890X", + "97327": "AB890X", + "97329": "AB890X", + "97330": "AB890X", + "97331": "AB890X", + "97333": "AB890X", + "97335": "AB890X", + "97336": "AB890X", + "97338": "AB890X", + "97339": "AB890X", + "97341": "AB890X", + "97342": "AB890X", + "97343": "AB890X", + "97344": "AB890X", + "97345": "AB890X", + "97346": "AB890X", + "97347": "AB890X", + "97348": "AB890X", + "97350": "AB890X", + "97351": "AB890X", + "97352": "AB890X", + "97355": "AB890X", + "97357": "AB890X", + "97358": "AB890X", + "97360": "AB890X", + "97361": "AB890X", + "97362": "AB890X", + "97364": "AB890X", + "97365": "AB890X", + "97366": "AB890X", + "97367": "AB890X", + "97368": "AB890X", + "97369": "AB890X", + "97370": "AB890X", + "97371": "AB890X", + "97372": "AB890X", + "97373": "AB890X", + "97374": "AB890X", + "97375": "AB890X", + "97376": "AB890X", + "97377": "AB890X", + "97378": "AB890X", + "97380": "AB890X", + "97381": "AB890X", + "97383": "AB890X", + "97384": "AB890X", + "97385": "AB890X", + "97386": "AB890X", + "97388": "AB890X", + "97389": "AB890X", + "97390": "AB890X", + "97391": "AB890X", + "97392": "AB890X", + "97394": "AB890X", + "97396": "AB890X", + "97401": "AB890X", + "97402": "AB890X", + "97403": "AB890X", + "97404": "AB890X", + "97405": "AB890X", + "97406": "AB890X", + "97407": "AB890X", + "97408": "AB890X", + "97409": "AB890X", + "97410": "AB890X", + "97411": "AB890X", + "97412": "AB890X", + "97413": "AB890X", + "97414": "AB890X", + "97415": "AB890X", + "97416": "AB890X", + "97417": "AB890X", + "97419": "AB890X", + "97420": "AB890X", + "97423": "AB890X", + "97424": "AB890X", + "97425": "AB890X", + "97426": "AB890X", + "97427": "AB890X", + "97428": "AB890X", + "97429": "AB890X", + "97430": "AB890X", + "97431": "AB890X", + "97432": "AB890X", + "97434": "AB890X", + "97435": "AB890X", + "97436": "AB890X", + "97437": "AB890X", + "97438": "AB890X", + "97439": "AB890X", + "97440": "AB890X", + "97441": "AB890X", + "97442": "AB890X", + "97443": "AB890X", + "97444": "AB890X", + "97446": "AB890X", + "97447": "AB890X", + "97448": "AB890X", + "97449": "AB890X", + "97450": "AB890X", + "97451": "AB890X", + "97452": "AB890X", + "97453": "AB890X", + "97454": "AB890X", + "97455": "AB890X", + "97456": "AB890X", + "97457": "AB890X", + "97458": "AB890X", + "97459": "AB890X", + "97461": "AB890X", + "97462": "AB890X", + "97463": "AB890X", + "97464": "AB890X", + "97465": "AB890X", + "97466": "AB890X", + "97467": "AB890X", + "97469": "AB890X", + "97470": "AB890X", + "97471": "AB890X", + "97472": "AB890X", + "97473": "AB890X", + "97476": "AB890X", + "97477": "AB890X", + "97478": "AB890X", + "97479": "AB890X", + "97480": "AB890X", + "97481": "AB890X", + "97482": "AB890X", + "97484": "AB890X", + "97486": "AB890X", + "97487": "AB890X", + "97488": "AB890X", + "97489": "AB890X", + "97490": "AB890X", + "97491": "AB890X", + "97492": "AB890X", + "97493": "AB890X", + "97494": "AB890X", + "97495": "AB890X", + "97496": "AB890X", + "97497": "AB890X", + "97498": "AB890X", + "97499": "AB890X", + "97501": "AB890X", + "97502": "AB890X", + "97503": "AB890X", + "97504": "AB890X", + "97520": "AB890X", + "97522": "AB890X", + "97523": "AB890X", + "97524": "AB890X", + "97525": "AB890X", + "97526": "AB890X", + "97527": "AB890X", + "97528": "AB890X", + "97530": "AB890X", + "97531": "AB890X", + "97532": "AB890X", + "97533": "AB890X", + "97534": "AB890X", + "97535": "AB890X", + "97536": "AB890X", + "97537": "AB890X", + "97538": "AB890X", + "97539": "AB890X", + "97540": "AB890X", + "97541": "AB890X", + "97543": "AB890X", + "97544": "AB890X", + "97601": "AB890X", + "97602": "AB890X", + "97603": "AB890X", + "97604": "AB890X", + "97620": "AB890X", + "97621": "AB890X", + "97622": "AB890X", + "97623": "AB890X", + "97624": "AB890X", + "97625": "AB890X", + "97626": "AB890X", + "97627": "AB890X", + "97630": "AB890X", + "97632": "AB890X", + "97633": "AB890X", + "97634": "AB890X", + "97635": "AB890X", + "97636": "AB890X", + "97637": "AB890X", + "97638": "AB890X", + "97639": "AB890X", + "97640": "AB890X", + "97641": "AB890X", + "97701": "AB890X", + "97702": "AB890X", + "97707": "AB890X", + "97708": "AB890X", + "97709": "AB890X", + "97710": "AB890X", + "97711": "AB890X", + "97712": "AB890X", + "97720": "AB890X", + "97721": "AB890X", + "97722": "AB890X", + "97730": "AB890X", + "97731": "AB890X", + "97732": "AB890X", + "97733": "AB890X", + "97734": "AB890X", + "97735": "AB890X", + "97736": "AB890X", + "97737": "AB890X", + "97738": "AB890X", + "97739": "AB890X", + "97741": "AB890X", + "97750": "AB890X", + "97751": "AB890X", + "97752": "AB890X", + "97753": "AB890X", + "97754": "AB890X", + "97756": "AB890X", + "97758": "AB890X", + "97759": "AB890X", + "97760": "AB890X", + "97761": "AB890X", + "97801": "AB890X", + "97810": "AB890X", + "97812": "AB890X", + "97813": "AB890X", + "97814": "AB890X", + "97817": "AB890X", + "97818": "AB890X", + "97819": "AB890X", + "97820": "AB890X", + "97823": "AB890X", + "97824": "AB890X", + "97825": "AB890X", + "97826": "AB890X", + "97827": "AB890X", + "97828": "AB890X", + "97830": "AB890X", + "97833": "AB890X", + "97834": "AB890X", + "97835": "AB890X", + "97836": "AB890X", + "97837": "AB890X", + "97838": "AB890X", + "97839": "AB890X", + "97840": "AB890X", + "97841": "AB890X", + "97842": "AB890X", + "97843": "AB890X", + "97844": "AB890X", + "97845": "AB890X", + "97846": "AB890X", + "97848": "AB890X", + "97850": "AB890X", + "97856": "AB890X", + "97857": "AB890X", + "97859": "AB890X", + "97861": "AB890X", + "97862": "AB890X", + "97864": "AB890X", + "97865": "AB890X", + "97867": "AB890X", + "97868": "AB890X", + "97869": "AB890X", + "97870": "AB890X", + "97873": "AB890X", + "97874": "AB890X", + "97875": "AB890X", + "97876": "AB890X", + "97877": "AB890X", + "97880": "AB890X", + "97882": "AB890X", + "97883": "AB890X", + "97884": "AB890X", + "97885": "AB890X", + "97886": "AB890X", + "97901": "AB890X", + "97902": "AB890X", + "97903": "AB890X", + "97904": "AB890X", + "97905": "AB890X", + "97906": "AB890X", + "97907": "AB890X", + "97908": "AB890X", + "97909": "AB890X", + "97910": "AB890X", + "97911": "AB890X", + "97913": "AB890X", + "97914": "AB890X", + "97917": "AB890X", + "97918": "AB890X", + "97920": "AB890X", + "98001": "AB890X", + "98002": "AB890X", + "98003": "AB890X", + "98004": "AB890X", + "98005": "AB890X", + "98006": "AB890X", + "98007": "AB890X", + "98008": "AB890X", + "98009": "AB890X", + "98010": "AB890X", + "98011": "AB890X", + "98012": "AB890X", + "98013": "AB890X", + "98014": "AB890X", + "98015": "AB890X", + "98019": "AB890X", + "98020": "AB890X", + "98021": "AB890X", + "98022": "AB890X", + "98023": "AB890X", + "98024": "AB890X", + "98025": "AB890X", + "98026": "AB890X", + "98027": "AB890X", + "98028": "AB890X", + "98029": "AB890X", + "98030": "AB890X", + "98031": "AB890X", + "98032": "AB890X", + "98033": "AB890X", + "98034": "AB890X", + "98035": "AB890X", + "98036": "AB890X", + "98037": "AB890X", + "98038": "AB890X", + "98039": "AB890X", + "98040": "AB890X", + "98041": "AB890X", + "98042": "AB890X", + "98043": "AB890X", + "98045": "AB890X", + "98046": "AB890X", + "98047": "AB890X", + "98050": "AB890X", + "98051": "AB890X", + "98052": "AB890X", + "98053": "AB890X", + "98054": "AB890X", + "98055": "AB890X", + "98056": "AB890X", + "98057": "AB890X", + "98058": "AB890X", + "98059": "AB890X", + "98061": "AB890X", + "98062": "AB890X", + "98063": "AB890X", + "98064": "AB890X", + "98065": "AB890X", + "98068": "AB890X", + "98070": "AB890X", + "98071": "AB890X", + "98072": "AB890X", + "98073": "AB890X", + "98074": "AB890X", + "98075": "AB890X", + "98077": "AB890X", + "98082": "AB890X", + "98083": "AB890X", + "98087": "AB890X", + "98089": "AB890X", + "98092": "AB890X", + "98093": "AB890X", + "98101": "AB890X", + "98102": "AB890X", + "98103": "AB890X", + "98104": "AB890X", + "98105": "AB890X", + "98106": "AB890X", + "98107": "AB890X", + "98108": "AB890X", + "98109": "AB890X", + "98110": "AB890X", + "98111": "AB890X", + "98112": "AB890X", + "98113": "AB890X", + "98114": "AB890X", + "98115": "AB890X", + "98116": "AB890X", + "98117": "AB890X", + "98118": "AB890X", + "98119": "AB890X", + "98121": "AB890X", + "98122": "AB890X", + "98124": "AB890X", + "98125": "AB890X", + "98126": "AB890X", + "98127": "AB890X", + "98129": "AB890X", + "98131": "AB890X", + "98132": "AB890X", + "98133": "AB890X", + "98134": "AB890X", + "98136": "AB890X", + "98138": "AB890X", + "98139": "AB890X", + "98141": "AB890X", + "98144": "AB890X", + "98145": "AB890X", + "98146": "AB890X", + "98148": "AB890X", + "98151": "AB890X", + "98154": "AB890X", + "98155": "AB890X", + "98158": "AB890X", + "98160": "AB890X", + "98161": "AB890X", + "98164": "AB890X", + "98165": "AB890X", + "98166": "AB890X", + "98168": "AB890X", + "98170": "AB890X", + "98171": "AB890X", + "98174": "AB890X", + "98175": "AB890X", + "98177": "AB890X", + "98178": "AB890X", + "98181": "AB890X", + "98184": "AB890X", + "98185": "AB890X", + "98188": "AB890X", + "98190": "AB890X", + "98191": "AB890X", + "98194": "AB890X", + "98195": "AB890X", + "98198": "AB890X", + "98199": "AB890X", + "98201": "AB890X", + "98203": "AB890X", + "98204": "AB890X", + "98205": "AB890X", + "98206": "AB890X", + "98207": "AB890X", + "98208": "AB890X", + "98213": "AB890X", + "98220": "AB890X", + "98221": "AB890X", + "98222": "AB890X", + "98223": "AB890X", + "98224": "AB890X", + "98225": "AB890X", + "98226": "AB890X", + "98227": "AB890X", + "98228": "AB890X", + "98229": "AB890X", + "98230": "AB890X", + "98231": "AB890X", + "98232": "AB890X", + "98233": "AB890X", + "98235": "AB890X", + "98236": "AB890X", + "98237": "AB890X", + "98238": "AB890X", + "98239": "AB890X", + "98240": "AB890X", + "98241": "AB890X", + "98243": "AB890X", + "98244": "AB890X", + "98245": "AB890X", + "98247": "AB890X", + "98248": "AB890X", + "98249": "AB890X", + "98250": "AB890X", + "98251": "AB890X", + "98252": "AB890X", + "98253": "AB890X", + "98255": "AB890X", + "98256": "AB890X", + "98257": "AB890X", + "98258": "AB890X", + "98259": "AB890X", + "98260": "AB890X", + "98261": "AB890X", + "98262": "AB890X", + "98263": "AB890X", + "98264": "AB890X", + "98266": "AB890X", + "98267": "AB890X", + "98270": "AB890X", + "98271": "AB890X", + "98272": "AB890X", + "98273": "AB890X", + "98274": "AB890X", + "98275": "AB890X", + "98276": "AB890X", + "98277": "AB890X", + "98278": "AB890X", + "98279": "AB890X", + "98280": "AB890X", + "98281": "AB890X", + "98282": "AB890X", + "98283": "AB890X", + "98284": "AB890X", + "98286": "AB890X", + "98287": "AB890X", + "98288": "AB890X", + "98290": "AB890X", + "98291": "AB890X", + "98292": "AB890X", + "98293": "AB890X", + "98294": "AB890X", + "98295": "AB890X", + "98296": "AB890X", + "98297": "AB890X", + "98303": "AB890X", + "98304": "AB890X", + "98305": "AB890X", + "98310": "AB890X", + "98311": "AB890X", + "98312": "AB890X", + "98314": "AB890X", + "98315": "AB890X", + "98320": "AB890X", + "98321": "AB890X", + "98322": "AB890X", + "98323": "AB890X", + "98324": "AB890X", + "98325": "AB890X", + "98326": "AB890X", + "98327": "AB890X", + "98328": "AB890X", + "98329": "AB890X", + "98330": "AB890X", + "98331": "AB890X", + "98332": "AB890X", + "98333": "AB890X", + "98335": "AB890X", + "98336": "AB890X", + "98337": "AB890X", + "98338": "AB890X", + "98339": "AB890X", + "98340": "AB890X", + "98342": "AB890X", + "98343": "AB890X", + "98344": "AB890X", + "98345": "AB890X", + "98346": "AB890X", + "98348": "AB890X", + "98349": "AB890X", + "98350": "AB890X", + "98351": "AB890X", + "98352": "AB890X", + "98353": "AB890X", + "98354": "AB890X", + "98355": "AB890X", + "98356": "AB890X", + "98357": "AB890X", + "98358": "AB890X", + "98359": "AB890X", + "98360": "AB890X", + "98361": "AB890X", + "98362": "AB890X", + "98363": "AB890X", + "98364": "AB890X", + "98365": "AB890X", + "98366": "AB890X", + "98367": "AB890X", + "98368": "AB890X", + "98370": "AB890X", + "98371": "AB890X", + "98372": "AB890X", + "98373": "AB890X", + "98374": "AB890X", + "98375": "AB890X", + "98376": "AB890X", + "98377": "AB890X", + "98378": "AB890X", + "98380": "AB890X", + "98381": "AB890X", + "98382": "AB890X", + "98383": "AB890X", + "98384": "AB890X", + "98385": "AB890X", + "98386": "AB890X", + "98387": "AB890X", + "98388": "AB890X", + "98390": "AB890X", + "98391": "AB890X", + "98392": "AB890X", + "98393": "AB890X", + "98394": "AB890X", + "98395": "AB890X", + "98396": "AB890X", + "98397": "AB890X", + "98398": "AB890X", + "98401": "AB890X", + "98402": "AB890X", + "98403": "AB890X", + "98404": "AB890X", + "98405": "AB890X", + "98406": "AB890X", + "98407": "AB890X", + "98408": "AB890X", + "98409": "AB890X", + "98411": "AB890X", + "98412": "AB890X", + "98413": "AB890X", + "98415": "AB890X", + "98416": "AB890X", + "98417": "AB890X", + "98418": "AB890X", + "98419": "AB890X", + "98421": "AB890X", + "98422": "AB890X", + "98424": "AB890X", + "98430": "AB890X", + "98431": "AB890X", + "98433": "AB890X", + "98438": "AB890X", + "98439": "AB890X", + "98442": "AB890X", + "98443": "AB890X", + "98444": "AB890X", + "98445": "AB890X", + "98446": "AB890X", + "98447": "AB890X", + "98448": "AB890X", + "98450": "AB890X", + "98455": "AB890X", + "98460": "AB890X", + "98464": "AB890X", + "98465": "AB890X", + "98466": "AB890X", + "98467": "AB890X", + "98471": "AB890X", + "98477": "AB890X", + "98481": "AB890X", + "98490": "AB890X", + "98492": "AB890X", + "98493": "AB890X", + "98496": "AB890X", + "98497": "AB890X", + "98498": "AB890X", + "98499": "AB890X", + "98501": "AB890X", + "98502": "AB890X", + "98503": "AB890X", + "98504": "AB890X", + "98505": "AB890X", + "98506": "AB890X", + "98507": "AB890X", + "98508": "AB890X", + "98509": "AB890X", + "98511": "AB890X", + "98512": "AB890X", + "98513": "AB890X", + "98516": "AB890X", + "98520": "AB890X", + "98522": "AB890X", + "98524": "AB890X", + "98526": "AB890X", + "98527": "AB890X", + "98528": "AB890X", + "98530": "AB890X", + "98531": "AB890X", + "98532": "AB890X", + "98533": "AB890X", + "98535": "AB890X", + "98536": "AB890X", + "98537": "AB890X", + "98538": "AB890X", + "98539": "AB890X", + "98540": "AB890X", + "98541": "AB890X", + "98542": "AB890X", + "98544": "AB890X", + "98546": "AB890X", + "98547": "AB890X", + "98548": "AB890X", + "98550": "AB890X", + "98552": "AB890X", + "98554": "AB890X", + "98555": "AB890X", + "98556": "AB890X", + "98557": "AB890X", + "98558": "AB890X", + "98559": "AB890X", + "98560": "AB890X", + "98561": "AB890X", + "98562": "AB890X", + "98563": "AB890X", + "98564": "AB890X", + "98565": "AB890X", + "98566": "AB890X", + "98568": "AB890X", + "98569": "AB890X", + "98570": "AB890X", + "98571": "AB890X", + "98572": "AB890X", + "98575": "AB890X", + "98576": "AB890X", + "98577": "AB890X", + "98579": "AB890X", + "98580": "AB890X", + "98581": "AB890X", + "98582": "AB890X", + "98583": "AB890X", + "98584": "AB890X", + "98585": "AB890X", + "98586": "AB890X", + "98587": "AB890X", + "98588": "AB890X", + "98589": "AB890X", + "98590": "AB890X", + "98591": "AB890X", + "98592": "AB890X", + "98593": "AB890X", + "98595": "AB890X", + "98596": "AB890X", + "98597": "AB890X", + "98599": "AB890X", + "98601": "AB890X", + "98602": "AB890X", + "98603": "AB890X", + "98604": "AB890X", + "98605": "AB890X", + "98606": "AB890X", + "98607": "AB890X", + "98609": "AB890X", + "98610": "AB890X", + "98611": "AB890X", + "98612": "AB890X", + "98613": "AB890X", + "98614": "AB890X", + "98616": "AB890X", + "98617": "AB890X", + "98619": "AB890X", + "98620": "AB890X", + "98621": "AB890X", + "98622": "AB890X", + "98623": "AB890X", + "98624": "AB890X", + "98625": "AB890X", + "98626": "AB890X", + "98628": "AB890X", + "98629": "AB890X", + "98631": "AB890X", + "98632": "AB890X", + "98635": "AB890X", + "98637": "AB890X", + "98638": "AB890X", + "98639": "AB890X", + "98640": "AB890X", + "98641": "AB890X", + "98642": "AB890X", + "98643": "AB890X", + "98644": "AB890X", + "98645": "AB890X", + "98647": "AB890X", + "98648": "AB890X", + "98649": "AB890X", + "98650": "AB890X", + "98651": "AB890X", + "98660": "AB890X", + "98661": "AB890X", + "98662": "AB890X", + "98663": "AB890X", + "98664": "AB890X", + "98665": "AB890X", + "98666": "AB890X", + "98667": "AB890X", + "98668": "AB890X", + "98670": "AB890X", + "98671": "AB890X", + "98672": "AB890X", + "98673": "AB890X", + "98674": "AB890X", + "98675": "AB890X", + "98682": "AB890X", + "98683": "AB890X", + "98684": "AB890X", + "98685": "AB890X", + "98686": "AB890X", + "98687": "AB890X", + "98801": "AB890X", + "98802": "AB890X", + "98807": "AB890X", + "98811": "AB890X", + "98812": "AB890X", + "98813": "AB890X", + "98814": "AB890X", + "98815": "AB890X", + "98816": "AB890X", + "98817": "AB890X", + "98819": "AB890X", + "98821": "AB890X", + "98822": "AB890X", + "98823": "AB890X", + "98824": "AB890X", + "98826": "AB890X", + "98827": "AB890X", + "98828": "AB890X", + "98829": "AB890X", + "98830": "AB890X", + "98831": "AB890X", + "98832": "AB890X", + "98833": "AB890X", + "98834": "AB890X", + "98836": "AB890X", + "98837": "AB890X", + "98840": "AB890X", + "98841": "AB890X", + "98843": "AB890X", + "98844": "AB890X", + "98845": "AB890X", + "98846": "AB890X", + "98847": "AB890X", + "98848": "AB890X", + "98849": "AB890X", + "98850": "AB890X", + "98851": "AB890X", + "98852": "AB890X", + "98853": "AB890X", + "98855": "AB890X", + "98856": "AB890X", + "98857": "AB890X", + "98858": "AB890X", + "98859": "AB890X", + "98860": "AB890X", + "98862": "AB890X", + "98901": "AB890X", + "98902": "AB890X", + "98903": "AB890X", + "98904": "AB890X", + "98907": "AB890X", + "98908": "AB890X", + "98909": "AB890X", + "98920": "AB890X", + "98921": "AB890X", + "98922": "AB890X", + "98923": "AB890X", + "98925": "AB890X", + "98926": "AB890X", + "98929": "AB890X", + "98930": "AB890X", + "98932": "AB890X", + "98933": "AB890X", + "98934": "AB890X", + "98935": "AB890X", + "98936": "AB890X", + "98937": "AB890X", + "98938": "AB890X", + "98939": "AB890X", + "98940": "AB890X", + "98941": "AB890X", + "98942": "AB890X", + "98943": "AB890X", + "98944": "AB890X", + "98946": "AB890X", + "98947": "AB890X", + "98948": "AB890X", + "98950": "AB890X", + "98951": "AB890X", + "98952": "AB890X", + "98953": "AB890X", + "99001": "AB890X", + "99003": "AB890X", + "99004": "AB890X", + "99005": "AB890X", + "99006": "AB890X", + "99008": "AB890X", + "99009": "AB890X", + "99011": "AB890X", + "99012": "AB890X", + "99013": "AB890X", + "99014": "AB890X", + "99016": "AB890X", + "99017": "AB890X", + "99018": "AB890X", + "99019": "AB890X", + "99020": "AB890X", + "99021": "AB890X", + "99022": "AB890X", + "99023": "AB890X", + "99025": "AB890X", + "99026": "AB890X", + "99027": "AB890X", + "99029": "AB890X", + "99030": "AB890X", + "99031": "AB890X", + "99032": "AB890X", + "99033": "AB890X", + "99034": "AB890X", + "99036": "AB890X", + "99037": "AB890X", + "99039": "AB890X", + "99040": "AB890X", + "99101": "AB890X", + "99102": "AB890X", + "99103": "AB890X", + "99104": "AB890X", + "99105": "AB890X", + "99107": "AB890X", + "99109": "AB890X", + "99110": "AB890X", + "99111": "AB890X", + "99113": "AB890X", + "99114": "AB890X", + "99115": "AB890X", + "99116": "AB890X", + "99117": "AB890X", + "99118": "AB890X", + "99119": "AB890X", + "99121": "AB890X", + "99122": "AB890X", + "99123": "AB890X", + "99124": "AB890X", + "99125": "AB890X", + "99126": "AB890X", + "99128": "AB890X", + "99129": "AB890X", + "99130": "AB890X", + "99131": "AB890X", + "99133": "AB890X", + "99134": "AB890X", + "99135": "AB890X", + "99136": "AB890X", + "99137": "AB890X", + "99138": "AB890X", + "99139": "AB890X", + "99140": "AB890X", + "99141": "AB890X", + "99143": "AB890X", + "99144": "AB890X", + "99146": "AB890X", + "99147": "AB890X", + "99148": "AB890X", + "99149": "AB890X", + "99150": "AB890X", + "99151": "AB890X", + "99152": "AB890X", + "99153": "AB890X", + "99154": "AB890X", + "99155": "AB890X", + "99156": "AB890X", + "99157": "AB890X", + "99158": "AB890X", + "99159": "AB890X", + "99160": "AB890X", + "99161": "AB890X", + "99163": "AB890X", + "99164": "AB890X", + "99165": "AB890X", + "99166": "AB890X", + "99167": "AB890X", + "99169": "AB890X", + "99170": "AB890X", + "99171": "AB890X", + "99173": "AB890X", + "99174": "AB890X", + "99176": "AB890X", + "99179": "AB890X", + "99180": "AB890X", + "99181": "AB890X", + "99185": "AB890X", + "99201": "AB890X", + "99202": "AB890X", + "99203": "AB890X", + "99204": "AB890X", + "99205": "AB890X", + "99206": "AB890X", + "99207": "AB890X", + "99208": "AB890X", + "99209": "AB890X", + "99210": "AB890X", + "99211": "AB890X", + "99212": "AB890X", + "99213": "AB890X", + "99214": "AB890X", + "99215": "AB890X", + "99216": "AB890X", + "99217": "AB890X", + "99218": "AB890X", + "99219": "AB890X", + "99220": "AB890X", + "99223": "AB890X", + "99224": "AB890X", + "99228": "AB890X", + "99251": "AB890X", + "99252": "AB890X", + "99256": "AB890X", + "99258": "AB890X", + "99260": "AB890X", + "99299": "AB890X", + "99301": "AB890X", + "99302": "AB890X", + "99320": "AB890X", + "99321": "AB890X", + "99322": "AB890X", + "99323": "AB890X", + "99324": "AB890X", + "99326": "AB890X", + "99328": "AB890X", + "99329": "AB890X", + "99330": "AB890X", + "99333": "AB890X", + "99335": "AB890X", + "99336": "AB890X", + "99337": "AB890X", + "99338": "AB890X", + "99341": "AB890X", + "99343": "AB890X", + "99344": "AB890X", + "99345": "AB890X", + "99346": "AB890X", + "99347": "AB890X", + "99348": "AB890X", + "99349": "AB890X", + "99350": "AB890X", + "99352": "AB890X", + "99353": "AB890X", + "99354": "AB890X", + "99356": "AB890X", + "99357": "AB890X", + "99359": "AB890X", + "99360": "AB890X", + "99361": "AB890X", + "99362": "AB890X", + "99363": "AB890X", + "99371": "AB890X", + "99401": "AB890X", + "99402": "AB890X", + "99403": "AB890X", + "99501": "AB886X", + "99502": "AB886X", + "99503": "AB886X", + "99504": "AB886X", + "99505": "AB886X", + "99506": "AB886X", + "99507": "AB886X", + "99508": "AB886X", + "99509": "AB886X", + "99510": "AB886X", + "99511": "AB886X", + "99513": "AB886X", + "99514": "AB886X", + "99515": "AB886X", + "99516": "AB886X", + "99517": "AB886X", + "99518": "AB886X", + "99519": "AB886X", + "99520": "AB886X", + "99521": "AB886X", + "99522": "AB886X", + "99523": "AB886X", + "99524": "AB886X", + "99529": "AB886X", + "99530": "AB886X", + "99540": "AB886X", + "99545": "AB886X", + "99546": "AB886X", + "99547": "AB886X", + "99548": "AB886X", + "99549": "AB886X", + "99550": "AB886X", + "99551": "AB886X", + "99552": "AB886X", + "99553": "AB886X", + "99554": "AB886X", + "99555": "AB886X", + "99556": "AB886X", + "99557": "AB886X", + "99558": "AB886X", + "99559": "AB886X", + "99561": "AB886X", + "99563": "AB886X", + "99564": "AB886X", + "99565": "AB886X", + "99566": "AB886X", + "99567": "AB886X", + "99568": "AB886X", + "99569": "AB886X", + "99571": "AB886X", + "99572": "AB886X", + "99573": "AB886X", + "99574": "AB886X", + "99575": "AB886X", + "99576": "AB886X", + "99577": "AB886X", + "99578": "AB886X", + "99579": "AB886X", + "99580": "AB886X", + "99581": "AB886X", + "99583": "AB886X", + "99585": "AB886X", + "99586": "AB886X", + "99587": "AB886X", + "99588": "AB886X", + "99589": "AB886X", + "99590": "AB886X", + "99591": "AB886X", + "99599": "AB886X", + "99602": "AB886X", + "99603": "AB886X", + "99604": "AB886X", + "99605": "AB886X", + "99606": "AB886X", + "99607": "AB886X", + "99608": "AB886X", + "99609": "AB886X", + "99610": "AB886X", + "99611": "AB886X", + "99612": "AB886X", + "99613": "AB886X", + "99614": "AB886X", + "99615": "AB886X", + "99619": "AB886X", + "99620": "AB886X", + "99621": "AB886X", + "99622": "AB886X", + "99624": "AB886X", + "99625": "AB886X", + "99626": "AB886X", + "99627": "AB886X", + "99628": "AB886X", + "99629": "AB886X", + "99630": "AB886X", + "99631": "AB886X", + "99632": "AB886X", + "99633": "AB886X", + "99634": "AB886X", + "99635": "AB886X", + "99636": "AB886X", + "99637": "AB886X", + "99638": "AB886X", + "99639": "AB886X", + "99640": "AB886X", + "99641": "AB886X", + "99643": "AB886X", + "99644": "AB886X", + "99645": "AB886X", + "99647": "AB886X", + "99648": "AB886X", + "99649": "AB886X", + "99650": "AB886X", + "99651": "AB886X", + "99652": "AB886X", + "99653": "AB886X", + "99654": "AB886X", + "99655": "AB886X", + "99656": "AB886X", + "99657": "AB886X", + "99658": "AB886X", + "99659": "AB886X", + "99660": "AB886X", + "99661": "AB886X", + "99662": "AB886X", + "99663": "AB886X", + "99664": "AB886X", + "99665": "AB886X", + "99666": "AB886X", + "99667": "AB886X", + "99668": "AB886X", + "99669": "AB886X", + "99670": "AB886X", + "99671": "AB886X", + "99672": "AB886X", + "99674": "AB886X", + "99675": "AB886X", + "99676": "AB886X", + "99677": "AB886X", + "99678": "AB886X", + "99679": "AB886X", + "99680": "AB886X", + "99681": "AB886X", + "99682": "AB886X", + "99683": "AB886X", + "99684": "AB886X", + "99685": "AB886X", + "99686": "AB886X", + "99687": "AB886X", + "99688": "AB886X", + "99689": "AB886X", + "99690": "AB886X", + "99691": "AB886X", + "99692": "AB886X", + "99693": "AB886X", + "99694": "AB886X", + "99695": "AB886X", + "99697": "AB886X", + "99701": "AB886X", + "99702": "AB886X", + "99703": "AB886X", + "99704": "AB886X", + "99705": "AB886X", + "99706": "AB886X", + "99707": "AB886X", + "99708": "AB886X", + "99709": "AB886X", + "99710": "AB886X", + "99711": "AB886X", + "99712": "AB886X", + "99714": "AB886X", + "99716": "AB886X", + "99720": "AB886X", + "99721": "AB886X", + "99722": "AB886X", + "99723": "AB886X", + "99724": "AB886X", + "99725": "AB886X", + "99726": "AB886X", + "99727": "AB886X", + "99729": "AB886X", + "99730": "AB886X", + "99731": "AB886X", + "99732": "AB886X", + "99733": "AB886X", + "99734": "AB886X", + "99736": "AB886X", + "99737": "AB886X", + "99738": "AB886X", + "99739": "AB886X", + "99740": "AB886X", + "99741": "AB886X", + "99742": "AB886X", + "99743": "AB886X", + "99744": "AB886X", + "99745": "AB886X", + "99746": "AB886X", + "99747": "AB886X", + "99748": "AB886X", + "99749": "AB886X", + "99750": "AB886X", + "99751": "AB886X", + "99752": "AB886X", + "99753": "AB886X", + "99754": "AB886X", + "99755": "AB886X", + "99756": "AB886X", + "99757": "AB886X", + "99758": "AB886X", + "99759": "AB886X", + "99760": "AB886X", + "99761": "AB886X", + "99762": "AB886X", + "99763": "AB886X", + "99764": "AB886X", + "99765": "AB886X", + "99766": "AB886X", + "99767": "AB886X", + "99768": "AB886X", + "99769": "AB886X", + "99770": "AB886X", + "99771": "AB886X", + "99772": "AB886X", + "99773": "AB886X", + "99774": "AB886X", + "99775": "AB886X", + "99776": "AB886X", + "99777": "AB886X", + "99778": "AB886X", + "99779": "AB886X", + "99780": "AB886X", + "99781": "AB886X", + "99782": "AB886X", + "99783": "AB886X", + "99784": "AB886X", + "99785": "AB886X", + "99786": "AB886X", + "99788": "AB886X", + "99789": "AB886X", + "99790": "AB886X", + "99791": "AB886X", + "99801": "AB886X", + "99802": "AB886X", + "99803": "AB886X", + "99811": "AB886X", + "99812": "AB886X", + "99820": "AB886X", + "99821": "AB886X", + "99824": "AB886X", + "99825": "AB886X", + "99826": "AB886X", + "99827": "AB886X", + "99829": "AB886X", + "99830": "AB886X", + "99832": "AB886X", + "99833": "AB886X", + "99835": "AB886X", + "99836": "AB886X", + "99840": "AB886X", + "99841": "AB886X", + "99850": "AB886X", + "99901": "AB886X", + "99903": "AB886X", + "99918": "AB886X", + "99919": "AB886X", + "99921": "AB886X", + "99922": "AB886X", + "99923": "AB886X", + "99925": "AB886X", + "99926": "AB886X", + "99927": "AB886X", + "99928": "AB886X", + "99929": "AB886X", + "99950": "AB886X", + "96700": "AB888X", + "96701": "AB888X", + "96703": "AB888X", + "96704": "AB888X", + "96705": "AB888X", + "96706": "AB888X", + "96707": "AB888X", + "96708": "AB888X", + "96709": "AB888X", + "96710": "AB888X", + "96712": "AB888X", + "96713": "AB888X", + "96714": "AB888X", + "96715": "AB888X", + "96716": "AB888X", + "96717": "AB888X", + "96718": "AB888X", + "96719": "AB888X", + "96720": "AB888X", + "96721": "AB888X", + "96722": "AB888X", + "96725": "AB888X", + "96726": "AB888X", + "96727": "AB888X", + "96728": "AB888X", + "96729": "AB888X", + "96730": "AB888X", + "96731": "AB888X", + "96732": "AB888X", + "96733": "AB888X", + "96734": "AB888X", + "96737": "AB888X", + "96738": "AB888X", + "96739": "AB888X", + "96740": "AB888X", + "96741": "AB888X", + "96742": "AB888X", + "96743": "AB888X", + "96744": "AB888X", + "96745": "AB888X", + "96746": "AB888X", + "96747": "AB888X", + "96748": "AB888X", + "96749": "AB888X", + "96750": "AB888X", + "96751": "AB888X", + "96752": "AB888X", + "96753": "AB888X", + "96754": "AB888X", + "96755": "AB888X", + "96756": "AB888X", + "96757": "AB888X", + "96759": "AB888X", + "96760": "AB888X", + "96761": "AB888X", + "96762": "AB888X", + "96763": "AB888X", + "96764": "AB888X", + "96765": "AB888X", + "96766": "AB888X", + "96767": "AB888X", + "96768": "AB888X", + "96769": "AB888X", + "96770": "AB888X", + "96771": "AB888X", + "96772": "AB888X", + "96773": "AB888X", + "96774": "AB888X", + "96776": "AB888X", + "96777": "AB888X", + "96778": "AB888X", + "96779": "AB888X", + "96780": "AB888X", + "96781": "AB888X", + "96782": "AB888X", + "96783": "AB888X", + "96784": "AB888X", + "96785": "AB888X", + "96786": "AB888X", + "96788": "AB888X", + "96789": "AB888X", + "96790": "AB888X", + "96791": "AB888X", + "96792": "AB888X", + "96793": "AB888X", + "96795": "AB888X", + "96796": "AB888X", + "96797": "AB888X", + "96801": "AB888X", + "96802": "AB888X", + "96803": "AB888X", + "96804": "AB888X", + "96805": "AB888X", + "96806": "AB888X", + "96807": "AB888X", + "96808": "AB888X", + "96809": "AB888X", + "96810": "AB888X", + "96811": "AB888X", + "96812": "AB888X", + "96813": "AB888X", + "96814": "AB888X", + "96815": "AB888X", + "96816": "AB888X", + "96817": "AB888X", + "96818": "AB888X", + "96819": "AB888X", + "96820": "AB888X", + "96821": "AB888X", + "96822": "AB888X", + "96823": "AB888X", + "96824": "AB888X", + "96825": "AB888X", + "96826": "AB888X", + "96827": "AB888X", + "96828": "AB888X", + "96830": "AB888X", + "96835": "AB888X", + "96836": "AB888X", + "96837": "AB888X", + "96838": "AB888X", + "96839": "AB888X", + "96840": "AB888X", + "96841": "AB888X", + "96843": "AB888X", + "96844": "AB888X", + "96846": "AB888X", + "96847": "AB888X", + "96848": "AB888X", + "96849": "AB888X", + "96850": "AB888X", + "96853": "AB888X", + "96854": "AB888X", + "96857": "AB888X", + "96858": "AB888X", + "96859": "AB888X", + "96860": "AB888X", + "96861": "AB888X", + "96863": "AB888X", + "96898": "AB888X", + "27006": "AB887X", + "27007": "AB887X", + "27009": "AB887X", + "27010": "AB887X", + "27011": "AB887X", + "27012": "AB887X", + "27013": "AB887X", + "27014": "AB887X", + "27016": "AB887X", + "27017": "AB887X", + "27018": "AB887X", + "27019": "AB887X", + "27020": "AB887X", + "27021": "AB887X", + "27022": "AB887X", + "27023": "AB887X", + "27024": "AB887X", + "27025": "AB887X", + "27027": "AB887X", + "27028": "AB887X", + "27030": "AB887X", + "27031": "AB887X", + "27040": "AB887X", + "27041": "AB887X", + "27042": "AB887X", + "27043": "AB887X", + "27045": "AB887X", + "27046": "AB887X", + "27047": "AB887X", + "27048": "AB887X", + "27049": "AB887X", + "27050": "AB887X", + "27051": "AB887X", + "27052": "AB887X", + "27053": "AB887X", + "27054": "AB887X", + "27055": "AB887X", + "27094": "AB887X", + "27098": "AB887X", + "27099": "AB887X", + "27101": "AB887X", + "27102": "AB887X", + "27103": "AB887X", + "27104": "AB887X", + "27105": "AB887X", + "27106": "AB887X", + "27107": "AB887X", + "27108": "AB887X", + "27109": "AB887X", + "27110": "AB887X", + "27111": "AB887X", + "27113": "AB887X", + "27114": "AB887X", + "27115": "AB887X", + "27116": "AB887X", + "27117": "AB887X", + "27120": "AB887X", + "27127": "AB887X", + "27130": "AB887X", + "27150": "AB887X", + "27151": "AB887X", + "27152": "AB887X", + "27155": "AB887X", + "27156": "AB887X", + "27157": "AB887X", + "27198": "AB887X", + "27199": "AB887X", + "27201": "AB888X", + "27202": "AB888X", + "27203": "AB887X", + "27204": "AB887X", + "27205": "AB887X", + "27207": "AB888X", + "27208": "AB888X", + "27209": "AB887X", + "27212": "AB888X", + "27213": "AB888X", + "27214": "AB887X", + "27215": "AB888X", + "27216": "AB888X", + "27217": "AB888X", + "27220": "AB888X", + "27228": "AB888X", + "27229": "AB887X", + "27230": "AB887X", + "27231": "AB888X", + "27233": "AB887X", + "27235": "AB887X", + "27237": "AB888X", + "27239": "AB887X", + "27242": "AB888X", + "27243": "AB888X", + "27244": "AB888X", + "27247": "AB887X", + "27248": "AB887X", + "27249": "AB887X", + "27252": "AB888X", + "27253": "AB888X", + "27256": "AB888X", + "27258": "AB888X", + "27259": "AB888X", + "27260": "AB887X", + "27261": "AB887X", + "27262": "AB887X", + "27263": "AB887X", + "27264": "AB887X", + "27265": "AB887X", + "27278": "AB888X", + "27281": "AB888X", + "27282": "AB887X", + "27283": "AB887X", + "27284": "AB887X", + "27285": "AB887X", + "27288": "AB887X", + "27289": "AB887X", + "27291": "AB888X", + "27292": "AB887X", + "27293": "AB887X", + "27294": "AB887X", + "27295": "AB887X", + "27298": "AB887X", + "27299": "AB887X", + "27301": "AB887X", + "27302": "AB888X", + "27305": "AB888X", + "27306": "AB887X", + "27310": "AB887X", + "27311": "AB888X", + "27312": "AB888X", + "27313": "AB887X", + "27314": "AB888X", + "27315": "AB888X", + "27316": "AB887X", + "27317": "AB887X", + "27320": "AB887X", + "27321": "AB887X", + "27322": "AB887X", + "27323": "AB887X", + "27325": "AB888X", + "27326": "AB887X", + "27330": "AB888X", + "27331": "AB888X", + "27332": "AB888X", + "27340": "AB888X", + "27341": "AB887X", + "27342": "AB887X", + "27343": "AB888X", + "27344": "AB888X", + "27349": "AB888X", + "27350": "AB887X", + "27351": "AB887X", + "27355": "AB887X", + "27356": "AB887X", + "27357": "AB887X", + "27358": "AB887X", + "27359": "AB888X", + "27360": "AB887X", + "27361": "AB887X", + "27370": "AB887X", + "27371": "AB887X", + "27373": "AB887X", + "27374": "AB887X", + "27375": "AB887X", + "27376": "AB888X", + "27377": "AB887X", + "27379": "AB888X", + "27395": "AB887X", + "27401": "AB887X", + "27402": "AB887X", + "27403": "AB887X", + "27404": "AB887X", + "27405": "AB887X", + "27406": "AB887X", + "27407": "AB887X", + "27408": "AB887X", + "27409": "AB887X", + "27410": "AB887X", + "27411": "AB887X", + "27412": "AB887X", + "27413": "AB887X", + "27415": "AB887X", + "27416": "AB887X", + "27417": "AB887X", + "27419": "AB887X", + "27420": "AB887X", + "27425": "AB887X", + "27427": "AB887X", + "27429": "AB887X", + "27435": "AB887X", + "27438": "AB887X", + "27455": "AB887X", + "27480": "AB887X", + "27495": "AB887X", + "27497": "AB887X", + "27498": "AB887X", + "27499": "AB887X", + "27501": "AB888X", + "27502": "AB888X", + "27503": "AB888X", + "27504": "AB888X", + "27505": "AB888X", + "27506": "AB888X", + "27507": "AB888X", + "27508": "AB888X", + "27509": "AB888X", + "27510": "AB888X", + "27511": "AB888X", + "27512": "AB888X", + "27513": "AB888X", + "27514": "AB888X", + "27515": "AB888X", + "27516": "AB888X", + "27517": "AB888X", + "27518": "AB888X", + "27519": "AB888X", + "27520": "AB888X", + "27521": "AB888X", + "27522": "AB888X", + "27523": "AB888X", + "27524": "AB888X", + "27525": "AB888X", + "27526": "AB888X", + "27527": "AB888X", + "27528": "AB888X", + "27529": "AB888X", + "27530": "AB888X", + "27531": "AB888X", + "27532": "AB888X", + "27533": "AB888X", + "27534": "AB888X", + "27536": "AB888X", + "27537": "AB888X", + "27539": "AB888X", + "27540": "AB888X", + "27541": "AB888X", + "27542": "AB888X", + "27543": "AB888X", + "27544": "AB888X", + "27545": "AB888X", + "27546": "AB888X", + "27549": "AB888X", + "27551": "AB888X", + "27552": "AB888X", + "27553": "AB888X", + "27555": "AB888X", + "27556": "AB888X", + "27557": "AB888X", + "27559": "AB888X", + "27560": "AB888X", + "27562": "AB888X", + "27563": "AB888X", + "27564": "AB888X", + "27565": "AB888X", + "27568": "AB888X", + "27569": "AB888X", + "27570": "AB888X", + "27571": "AB888X", + "27572": "AB888X", + "27573": "AB888X", + "27574": "AB888X", + "27576": "AB888X", + "27577": "AB888X", + "27581": "AB888X", + "27582": "AB888X", + "27583": "AB888X", + "27584": "AB888X", + "27586": "AB888X", + "27587": "AB888X", + "27588": "AB888X", + "27589": "AB888X", + "27591": "AB888X", + "27592": "AB888X", + "27593": "AB888X", + "27594": "AB888X", + "27596": "AB888X", + "27597": "AB888X", + "27599": "AB888X", + "27601": "AB888X", + "27602": "AB888X", + "27603": "AB888X", + "27604": "AB888X", + "27605": "AB888X", + "27606": "AB888X", + "27607": "AB888X", + "27608": "AB888X", + "27609": "AB888X", + "27610": "AB888X", + "27611": "AB888X", + "27612": "AB888X", + "27613": "AB888X", + "27614": "AB888X", + "27615": "AB888X", + "27616": "AB888X", + "27617": "AB888X", + "27619": "AB888X", + "27620": "AB888X", + "27621": "AB888X", + "27622": "AB888X", + "27623": "AB888X", + "27624": "AB888X", + "27625": "AB888X", + "27626": "AB888X", + "27627": "AB888X", + "27628": "AB888X", + "27629": "AB888X", + "27634": "AB888X", + "27635": "AB888X", + "27636": "AB888X", + "27640": "AB888X", + "27650": "AB888X", + "27656": "AB888X", + "27658": "AB888X", + "27661": "AB888X", + "27668": "AB888X", + "27675": "AB888X", + "27676": "AB888X", + "27690": "AB888X", + "27695": "AB888X", + "27697": "AB888X", + "27698": "AB888X", + "27699": "AB888X", + "27701": "AB888X", + "27702": "AB888X", + "27703": "AB888X", + "27704": "AB888X", + "27705": "AB888X", + "27706": "AB888X", + "27707": "AB888X", + "27708": "AB888X", + "27709": "AB888X", + "27710": "AB888X", + "27711": "AB888X", + "27712": "AB888X", + "27713": "AB888X", + "27715": "AB888X", + "27717": "AB888X", + "27722": "AB888X", + "27801": "AB888X", + "27802": "AB888X", + "27803": "AB888X", + "27804": "AB888X", + "27805": "AB888X", + "27806": "AB888X", + "27807": "AB888X", + "27808": "AB888X", + "27809": "AB888X", + "27810": "AB888X", + "27811": "AB888X", + "27812": "AB888X", + "27813": "AB888X", + "27814": "AB888X", + "27815": "AB888X", + "27816": "AB888X", + "27817": "AB888X", + "27818": "AB892X", + "27819": "AB888X", + "27820": "AB888X", + "27821": "AB888X", + "27822": "AB888X", + "27823": "AB888X", + "27824": "AB888X", + "27825": "AB888X", + "27826": "AB888X", + "27827": "AB888X", + "27828": "AB888X", + "27829": "AB888X", + "27830": "AB888X", + "27831": "AB888X", + "27832": "AB888X", + "27833": "AB888X", + "27834": "AB888X", + "27835": "AB888X", + "27836": "AB888X", + "27837": "AB888X", + "27839": "AB888X", + "27840": "AB888X", + "27841": "AB888X", + "27842": "AB888X", + "27843": "AB888X", + "27844": "AB888X", + "27845": "AB888X", + "27846": "AB888X", + "27847": "AB888X", + "27849": "AB888X", + "27850": "AB888X", + "27851": "AB888X", + "27852": "AB888X", + "27853": "AB888X", + "27854": "AB888X", + "27855": "AB892X", + "27856": "AB888X", + "27857": "AB888X", + "27858": "AB888X", + "27860": "AB888X", + "27861": "AB888X", + "27862": "AB888X", + "27863": "AB888X", + "27864": "AB888X", + "27865": "AB888X", + "27866": "AB888X", + "27867": "AB888X", + "27868": "AB888X", + "27869": "AB888X", + "27870": "AB888X", + "27871": "AB888X", + "27872": "AB888X", + "27873": "AB888X", + "27874": "AB888X", + "27875": "AB888X", + "27876": "AB888X", + "27877": "AB888X", + "27878": "AB888X", + "27879": "AB888X", + "27880": "AB888X", + "27881": "AB888X", + "27882": "AB888X", + "27883": "AB888X", + "27884": "AB888X", + "27885": "AB888X", + "27886": "AB888X", + "27887": "AB888X", + "27888": "AB888X", + "27889": "AB888X", + "27890": "AB888X", + "27891": "AB888X", + "27892": "AB888X", + "27893": "AB888X", + "27894": "AB888X", + "27895": "AB888X", + "27896": "AB888X", + "27897": "AB888X", + "27906": "AB892X", + "27907": "AB892X", + "27909": "AB892X", + "27910": "AB892X", + "27915": "AB892X", + "27916": "AB892X", + "27917": "AB892X", + "27919": "AB892X", + "27920": "AB892X", + "27921": "AB892X", + "27922": "AB892X", + "27923": "AB892X", + "27924": "AB888X", + "27925": "AB892X", + "27926": "AB892X", + "27927": "AB892X", + "27928": "AB892X", + "27929": "AB892X", + "27930": "AB892X", + "27932": "AB892X", + "27935": "AB892X", + "27936": "AB892X", + "27937": "AB892X", + "27938": "AB892X", + "27939": "AB892X", + "27941": "AB892X", + "27942": "AB892X", + "27943": "AB892X", + "27944": "AB892X", + "27946": "AB892X", + "27947": "AB892X", + "27948": "AB892X", + "27949": "AB892X", + "27950": "AB892X", + "27953": "AB892X", + "27954": "AB892X", + "27956": "AB892X", + "27957": "AB888X", + "27958": "AB892X", + "27959": "AB892X", + "27960": "AB888X", + "27962": "AB892X", + "27964": "AB892X", + "27965": "AB892X", + "27966": "AB892X", + "27967": "AB888X", + "27968": "AB892X", + "27969": "AB892X", + "27970": "AB892X", + "27972": "AB892X", + "27973": "AB892X", + "27974": "AB892X", + "27976": "AB892X", + "27978": "AB892X", + "27979": "AB892X", + "27980": "AB892X", + "27981": "AB892X", + "27982": "AB892X", + "27983": "AB888X", + "27985": "AB892X", + "27986": "AB892X", + "28001": "AB887X", + "28002": "AB887X", + "28006": "AB887X", + "28007": "AB887X", + "28009": "AB887X", + "28010": "AB887X", + "28012": "AB887X", + "28016": "AB887X", + "28017": "AB887X", + "28018": "AB895X", + "28019": "AB895X", + "28020": "AB887X", + "28021": "AB887X", + "28023": "AB887X", + "28024": "AB895X", + "28025": "AB887X", + "28026": "AB887X", + "28027": "AB887X", + "28031": "AB887X", + "28032": "AB887X", + "28033": "AB887X", + "28034": "AB887X", + "28035": "AB887X", + "28036": "AB887X", + "28037": "AB887X", + "28038": "AB887X", + "28039": "AB887X", + "28040": "AB895X", + "28041": "AB887X", + "28042": "AB887X", + "28043": "AB895X", + "28052": "AB887X", + "28053": "AB887X", + "28054": "AB887X", + "28055": "AB887X", + "28056": "AB887X", + "28070": "AB887X", + "28071": "AB887X", + "28072": "AB887X", + "28073": "AB887X", + "28074": "AB895X", + "28075": "AB887X", + "28076": "AB895X", + "28077": "AB887X", + "28078": "AB887X", + "28079": "AB887X", + "28080": "AB887X", + "28081": "AB887X", + "28082": "AB887X", + "28083": "AB887X", + "28086": "AB887X", + "28088": "AB887X", + "28089": "AB887X", + "28090": "AB887X", + "28091": "AB887X", + "28092": "AB887X", + "28093": "AB887X", + "28097": "AB887X", + "28098": "AB887X", + "28101": "AB887X", + "28102": "AB887X", + "28103": "AB887X", + "28104": "AB887X", + "28105": "AB887X", + "28106": "AB887X", + "28107": "AB887X", + "28108": "AB887X", + "28109": "AB887X", + "28110": "AB887X", + "28111": "AB887X", + "28112": "AB887X", + "28114": "AB887X", + "28115": "AB887X", + "28117": "AB887X", + "28119": "AB887X", + "28120": "AB887X", + "28123": "AB887X", + "28124": "AB887X", + "28125": "AB887X", + "28126": "AB887X", + "28127": "AB887X", + "28128": "AB887X", + "28129": "AB887X", + "28130": "AB887X", + "28133": "AB887X", + "28134": "AB887X", + "28135": "AB887X", + "28136": "AB887X", + "28137": "AB887X", + "28138": "AB887X", + "28139": "AB895X", + "28144": "AB887X", + "28145": "AB887X", + "28146": "AB887X", + "28147": "AB887X", + "28150": "AB887X", + "28151": "AB887X", + "28152": "AB887X", + "28159": "AB887X", + "28160": "AB895X", + "28163": "AB887X", + "28164": "AB887X", + "28166": "AB887X", + "28167": "AB895X", + "28168": "AB887X", + "28169": "AB887X", + "28170": "AB887X", + "28173": "AB887X", + "28174": "AB887X", + "28201": "AB887X", + "28202": "AB887X", + "28203": "AB887X", + "28204": "AB887X", + "28205": "AB887X", + "28206": "AB887X", + "28207": "AB887X", + "28208": "AB887X", + "28209": "AB887X", + "28210": "AB887X", + "28211": "AB887X", + "28212": "AB887X", + "28213": "AB887X", + "28214": "AB887X", + "28215": "AB887X", + "28216": "AB887X", + "28217": "AB887X", + "28218": "AB887X", + "28219": "AB887X", + "28220": "AB887X", + "28221": "AB887X", + "28222": "AB887X", + "28223": "AB887X", + "28224": "AB887X", + "28226": "AB887X", + "28227": "AB887X", + "28228": "AB887X", + "28229": "AB887X", + "28230": "AB887X", + "28231": "AB887X", + "28232": "AB887X", + "28233": "AB887X", + "28234": "AB887X", + "28235": "AB887X", + "28236": "AB887X", + "28237": "AB887X", + "28241": "AB887X", + "28242": "AB887X", + "28243": "AB887X", + "28244": "AB887X", + "28246": "AB887X", + "28247": "AB887X", + "28250": "AB887X", + "28253": "AB887X", + "28254": "AB887X", + "28255": "AB887X", + "28256": "AB887X", + "28258": "AB887X", + "28260": "AB887X", + "28262": "AB887X", + "28263": "AB887X", + "28265": "AB887X", + "28266": "AB887X", + "28269": "AB887X", + "28270": "AB887X", + "28271": "AB887X", + "28272": "AB887X", + "28273": "AB887X", + "28274": "AB887X", + "28275": "AB887X", + "28277": "AB887X", + "28278": "AB887X", + "28280": "AB887X", + "28281": "AB887X", + "28282": "AB887X", + "28284": "AB887X", + "28285": "AB887X", + "28287": "AB887X", + "28288": "AB887X", + "28289": "AB887X", + "28290": "AB887X", + "28296": "AB887X", + "28297": "AB887X", + "28299": "AB887X", + "28301": "AB888X", + "28302": "AB888X", + "28303": "AB888X", + "28304": "AB888X", + "28305": "AB888X", + "28306": "AB888X", + "28307": "AB888X", + "28308": "AB888X", + "28309": "AB888X", + "28310": "AB888X", + "28311": "AB888X", + "28312": "AB888X", + "28314": "AB888X", + "28315": "AB888X", + "28318": "AB888X", + "28319": "AB888X", + "28320": "AB888X", + "28323": "AB888X", + "28325": "AB888X", + "28326": "AB888X", + "28327": "AB888X", + "28328": "AB888X", + "28329": "AB888X", + "28330": "AB887X", + "28331": "AB888X", + "28332": "AB888X", + "28333": "AB888X", + "28334": "AB888X", + "28335": "AB888X", + "28337": "AB888X", + "28338": "AB887X", + "28339": "AB888X", + "28340": "AB888X", + "28341": "AB888X", + "28342": "AB888X", + "28343": "AB888X", + "28344": "AB888X", + "28345": "AB887X", + "28347": "AB887X", + "28348": "AB888X", + "28349": "AB888X", + "28350": "AB888X", + "28351": "AB888X", + "28352": "AB888X", + "28353": "AB888X", + "28355": "AB888X", + "28356": "AB888X", + "28357": "AB888X", + "28358": "AB888X", + "28359": "AB888X", + "28360": "AB888X", + "28362": "AB888X", + "28363": "AB887X", + "28364": "AB888X", + "28365": "AB888X", + "28366": "AB888X", + "28367": "AB887X", + "28368": "AB888X", + "28369": "AB888X", + "28370": "AB888X", + "28371": "AB888X", + "28372": "AB888X", + "28373": "AB888X", + "28374": "AB888X", + "28375": "AB888X", + "28376": "AB888X", + "28377": "AB888X", + "28378": "AB888X", + "28379": "AB887X", + "28380": "AB887X", + "28382": "AB888X", + "28383": "AB888X", + "28384": "AB888X", + "28385": "AB888X", + "28386": "AB888X", + "28387": "AB888X", + "28388": "AB888X", + "28390": "AB888X", + "28391": "AB888X", + "28392": "AB888X", + "28393": "AB888X", + "28394": "AB888X", + "28395": "AB888X", + "28396": "AB888X", + "28398": "AB888X", + "28399": "AB888X", + "28401": "AB888X", + "28402": "AB888X", + "28403": "AB888X", + "28404": "AB888X", + "28405": "AB888X", + "28406": "AB888X", + "28407": "AB888X", + "28408": "AB888X", + "28409": "AB888X", + "28410": "AB888X", + "28411": "AB888X", + "28412": "AB888X", + "28420": "AB888X", + "28421": "AB888X", + "28422": "AB888X", + "28423": "AB888X", + "28424": "AB888X", + "28425": "AB888X", + "28428": "AB888X", + "28429": "AB888X", + "28430": "AB888X", + "28431": "AB888X", + "28432": "AB888X", + "28433": "AB888X", + "28434": "AB888X", + "28435": "AB888X", + "28436": "AB888X", + "28438": "AB888X", + "28439": "AB888X", + "28441": "AB888X", + "28442": "AB888X", + "28443": "AB888X", + "28444": "AB888X", + "28445": "AB888X", + "28447": "AB888X", + "28448": "AB888X", + "28449": "AB888X", + "28450": "AB888X", + "28451": "AB888X", + "28452": "AB888X", + "28453": "AB888X", + "28454": "AB888X", + "28455": "AB888X", + "28456": "AB888X", + "28457": "AB888X", + "28458": "AB888X", + "28459": "AB888X", + "28460": "AB888X", + "28461": "AB888X", + "28462": "AB888X", + "28463": "AB888X", + "28464": "AB888X", + "28465": "AB888X", + "28466": "AB888X", + "28467": "AB888X", + "28468": "AB888X", + "28469": "AB888X", + "28470": "AB888X", + "28472": "AB888X", + "28478": "AB888X", + "28479": "AB888X", + "28480": "AB888X", + "28501": "AB888X", + "28502": "AB888X", + "28503": "AB888X", + "28504": "AB888X", + "28508": "AB888X", + "28509": "AB888X", + "28510": "AB888X", + "28511": "AB888X", + "28512": "AB888X", + "28513": "AB888X", + "28515": "AB888X", + "28516": "AB888X", + "28518": "AB888X", + "28519": "AB888X", + "28520": "AB888X", + "28521": "AB888X", + "28522": "AB888X", + "28523": "AB888X", + "28524": "AB888X", + "28525": "AB888X", + "28526": "AB888X", + "28527": "AB888X", + "28528": "AB888X", + "28529": "AB888X", + "28530": "AB888X", + "28531": "AB888X", + "28532": "AB888X", + "28533": "AB888X", + "28537": "AB888X", + "28538": "AB888X", + "28539": "AB888X", + "28540": "AB888X", + "28541": "AB888X", + "28542": "AB888X", + "28543": "AB888X", + "28544": "AB888X", + "28545": "AB888X", + "28546": "AB888X", + "28547": "AB888X", + "28551": "AB888X", + "28552": "AB888X", + "28553": "AB888X", + "28554": "AB888X", + "28555": "AB888X", + "28556": "AB888X", + "28557": "AB888X", + "28560": "AB888X", + "28561": "AB888X", + "28562": "AB888X", + "28563": "AB888X", + "28564": "AB888X", + "28570": "AB888X", + "28571": "AB888X", + "28572": "AB888X", + "28573": "AB888X", + "28574": "AB888X", + "28575": "AB888X", + "28577": "AB888X", + "28578": "AB888X", + "28579": "AB888X", + "28580": "AB888X", + "28581": "AB888X", + "28582": "AB888X", + "28583": "AB888X", + "28584": "AB888X", + "28585": "AB888X", + "28586": "AB888X", + "28587": "AB888X", + "28589": "AB888X", + "28590": "AB888X", + "28594": "AB888X", + "28601": "AB887X", + "28602": "AB887X", + "28603": "AB887X", + "28604": "AB887X", + "28605": "AB887X", + "28606": "AB887X", + "28607": "AB887X", + "28608": "AB887X", + "28609": "AB887X", + "28610": "AB887X", + "28611": "AB887X", + "28612": "AB887X", + "28613": "AB887X", + "28615": "AB887X", + "28616": "AB887X", + "28617": "AB887X", + "28618": "AB887X", + "28619": "AB887X", + "28621": "AB887X", + "28622": "AB887X", + "28623": "AB892X", + "28624": "AB887X", + "28625": "AB887X", + "28626": "AB887X", + "28627": "AB892X", + "28628": "AB887X", + "28629": "AB887X", + "28630": "AB887X", + "28631": "AB887X", + "28633": "AB887X", + "28634": "AB887X", + "28635": "AB887X", + "28636": "AB887X", + "28637": "AB887X", + "28638": "AB887X", + "28640": "AB887X", + "28641": "AB887X", + "28642": "AB887X", + "28643": "AB887X", + "28644": "AB892X", + "28645": "AB887X", + "28646": "AB887X", + "28647": "AB887X", + "28649": "AB887X", + "28650": "AB887X", + "28651": "AB887X", + "28652": "AB887X", + "28653": "AB887X", + "28654": "AB887X", + "28655": "AB887X", + "28656": "AB887X", + "28657": "AB887X", + "28658": "AB887X", + "28659": "AB887X", + "28660": "AB887X", + "28661": "AB887X", + "28662": "AB887X", + "28663": "AB892X", + "28664": "AB887X", + "28665": "AB887X", + "28666": "AB887X", + "28667": "AB887X", + "28668": "AB892X", + "28669": "AB887X", + "28670": "AB887X", + "28671": "AB887X", + "28672": "AB887X", + "28673": "AB887X", + "28674": "AB887X", + "28675": "AB892X", + "28676": "AB887X", + "28677": "AB887X", + "28678": "AB887X", + "28679": "AB887X", + "28680": "AB887X", + "28681": "AB887X", + "28682": "AB887X", + "28683": "AB887X", + "28684": "AB887X", + "28685": "AB887X", + "28687": "AB887X", + "28688": "AB887X", + "28689": "AB887X", + "28690": "AB887X", + "28691": "AB887X", + "28692": "AB887X", + "28693": "AB887X", + "28694": "AB887X", + "28697": "AB887X", + "28698": "AB887X", + "28699": "AB887X", + "28701": "AB895X", + "28702": "AB895X", + "28704": "AB895X", + "28705": "AB895X", + "28707": "AB895X", + "28708": "AB895X", + "28709": "AB895X", + "28710": "AB895X", + "28711": "AB895X", + "28712": "AB895X", + "28713": "AB895X", + "28714": "AB895X", + "28715": "AB895X", + "28716": "AB895X", + "28717": "AB895X", + "28718": "AB895X", + "28719": "AB895X", + "28720": "AB895X", + "28721": "AB895X", + "28722": "AB895X", + "28723": "AB895X", + "28724": "AB895X", + "28725": "AB895X", + "28726": "AB895X", + "28727": "AB895X", + "28728": "AB895X", + "28729": "AB895X", + "28730": "AB895X", + "28731": "AB895X", + "28732": "AB895X", + "28733": "AB895X", + "28734": "AB895X", + "28735": "AB895X", + "28736": "AB895X", + "28737": "AB887X", + "28738": "AB895X", + "28739": "AB895X", + "28740": "AB895X", + "28741": "AB895X", + "28742": "AB895X", + "28743": "AB895X", + "28744": "AB895X", + "28745": "AB895X", + "28746": "AB895X", + "28747": "AB895X", + "28748": "AB895X", + "28749": "AB887X", + "28750": "AB895X", + "28751": "AB895X", + "28752": "AB887X", + "28753": "AB895X", + "28754": "AB895X", + "28755": "AB895X", + "28756": "AB895X", + "28757": "AB895X", + "28758": "AB895X", + "28759": "AB895X", + "28760": "AB895X", + "28761": "AB887X", + "28762": "AB887X", + "28763": "AB895X", + "28765": "AB895X", + "28766": "AB895X", + "28768": "AB895X", + "28770": "AB895X", + "28771": "AB895X", + "28772": "AB895X", + "28773": "AB895X", + "28774": "AB895X", + "28775": "AB895X", + "28776": "AB895X", + "28777": "AB895X", + "28778": "AB895X", + "28779": "AB895X", + "28781": "AB895X", + "28782": "AB895X", + "28783": "AB895X", + "28784": "AB895X", + "28785": "AB895X", + "28786": "AB895X", + "28787": "AB895X", + "28788": "AB895X", + "28789": "AB895X", + "28790": "AB895X", + "28791": "AB895X", + "28792": "AB895X", + "28793": "AB895X", + "28801": "AB895X", + "28802": "AB895X", + "28803": "AB895X", + "28804": "AB895X", + "28805": "AB895X", + "28806": "AB895X", + "28810": "AB895X", + "28813": "AB895X", + "28814": "AB895X", + "28815": "AB895X", + "28816": "AB895X", + "28901": "AB895X", + "28902": "AB889X", + "28903": "AB895X", + "28904": "AB889X", + "28905": "AB895X", + "28906": "AB895X", + "28909": "AB889X", + "27268": "AB887X", + "88901": "AB889X", + "88905": "AB889X", + "89001": "AB889X", + "89002": "AB889X", + "89003": "AB892X", + "89004": "AB892X", + "89005": "AB889X", + "89006": "AB889X", + "89007": "AB889X", + "89008": "AB889X", + "89009": "AB889X", + "89010": "AB889X", + "89011": "AB889X", + "89012": "AB889X", + "89013": "AB887X", + "89014": "AB889X", + "89015": "AB889X", + "89016": "AB889X", + "89017": "AB889X", + "89018": "AB889X", + "89019": "AB889X", + "89020": "AB889X", + "89021": "AB887X", + "89022": "AB887X", + "89023": "AB887X", + "89024": "AB889X", + "89025": "AB889X", + "89026": "AB889X", + "89027": "AB889X", + "89028": "AB887X", + "89029": "AB887X", + "89030": "AB889X", + "89031": "AB889X", + "89032": "AB889X", + "89033": "AB889X", + "89036": "AB889X", + "89037": "AB889X", + "89039": "AB889X", + "89040": "AB889X", + "89041": "AB889X", + "89042": "AB889X", + "89043": "AB889X", + "89044": "AB889X", + "89045": "AB887X", + "89046": "AB889X", + "89047": "AB889X", + "89048": "AB889X", + "89049": "AB889X", + "89052": "AB889X", + "89053": "AB889X", + "89060": "AB889X", + "89061": "AB889X", + "89067": "AB889X", + "89070": "AB889X", + "89074": "AB889X", + "89077": "AB889X", + "89081": "AB889X", + "89084": "AB889X", + "89085": "AB889X", + "89086": "AB889X", + "89087": "AB889X", + "89101": "AB889X", + "89102": "AB889X", + "89103": "AB889X", + "89104": "AB889X", + "89105": "AB889X", + "89106": "AB889X", + "89107": "AB889X", + "89108": "AB889X", + "89109": "AB889X", + "89110": "AB889X", + "89111": "AB889X", + "89112": "AB889X", + "89113": "AB889X", + "89114": "AB889X", + "89115": "AB889X", + "89116": "AB889X", + "89117": "AB889X", + "89118": "AB889X", + "89119": "AB889X", + "89120": "AB889X", + "89121": "AB889X", + "89122": "AB889X", + "89123": "AB889X", + "89124": "AB889X", + "89125": "AB889X", + "89126": "AB889X", + "89127": "AB889X", + "89128": "AB889X", + "89129": "AB889X", + "89130": "AB889X", + "89131": "AB889X", + "89132": "AB889X", + "89133": "AB889X", + "89134": "AB889X", + "89135": "AB889X", + "89136": "AB889X", + "89137": "AB889X", + "89138": "AB889X", + "89139": "AB889X", + "89140": "AB889X", + "89141": "AB889X", + "89142": "AB889X", + "89143": "AB889X", + "89144": "AB889X", + "89145": "AB889X", + "89146": "AB889X", + "89147": "AB889X", + "89148": "AB889X", + "89149": "AB889X", + "89150": "AB889X", + "89151": "AB889X", + "89152": "AB889X", + "89153": "AB889X", + "89154": "AB889X", + "89155": "AB889X", + "89156": "AB889X", + "89157": "AB889X", + "89159": "AB889X", + "89160": "AB889X", + "89161": "AB889X", + "89162": "AB889X", + "89163": "AB889X", + "89164": "AB889X", + "89165": "AB889X", + "89166": "AB889X", + "89169": "AB889X", + "89170": "AB889X", + "89173": "AB889X", + "89177": "AB889X", + "89178": "AB889X", + "89179": "AB889X", + "89180": "AB889X", + "89183": "AB889X", + "89185": "AB889X", + "89191": "AB889X", + "89193": "AB889X", + "89195": "AB889X", + "89199": "AB889X", + "89301": "AB892X", + "89310": "AB889X", + "89311": "AB889X", + "89314": "AB887X", + "89315": "AB892X", + "89316": "AB892X", + "89317": "AB887X", + "89318": "AB887X", + "89319": "AB887X", + "89402": "AB887X", + "89403": "AB887X", + "89404": "AB887X", + "89405": "AB887X", + "89406": "AB887X", + "89407": "AB887X", + "89408": "AB887X", + "89409": "AB887X", + "89410": "AB887X", + "89411": "AB887X", + "89412": "AB887X", + "89413": "AB887X", + "89414": "AB887X", + "89415": "AB889X", + "89418": "AB887X", + "89419": "AB887X", + "89420": "AB887X", + "89421": "AB887X", + "89422": "AB887X", + "89423": "AB887X", + "89424": "AB889X", + "89425": "AB889X", + "89426": "AB889X", + "89427": "AB887X", + "89428": "AB887X", + "89429": "AB887X", + "89430": "AB887X", + "89431": "AB887X", + "89432": "AB887X", + "89433": "AB887X", + "89434": "AB887X", + "89435": "AB887X", + "89436": "AB887X", + "89438": "AB887X", + "89439": "AB887X", + "89440": "AB887X", + "89441": "AB887X", + "89442": "AB887X", + "89444": "AB887X", + "89445": "AB887X", + "89446": "AB887X", + "89447": "AB887X", + "89448": "AB887X", + "89449": "AB887X", + "89450": "AB887X", + "89451": "AB887X", + "89452": "AB887X", + "89460": "AB887X", + "89496": "AB887X", + "89501": "AB887X", + "89502": "AB887X", + "89503": "AB887X", + "89504": "AB887X", + "89505": "AB887X", + "89506": "AB887X", + "89507": "AB887X", + "89509": "AB887X", + "89510": "AB887X", + "89511": "AB887X", + "89512": "AB887X", + "89513": "AB887X", + "89515": "AB887X", + "89519": "AB887X", + "89520": "AB887X", + "89521": "AB887X", + "89523": "AB887X", + "89533": "AB887X", + "89555": "AB887X", + "89557": "AB887X", + "89570": "AB887X", + "89595": "AB887X", + "89599": "AB887X", + "89701": "AB887X", + "89702": "AB887X", + "89703": "AB887X", + "89704": "AB887X", + "89705": "AB887X", + "89706": "AB887X", + "89711": "AB887X", + "89712": "AB887X", + "89713": "AB887X", + "89714": "AB887X", + "89721": "AB887X", + "89801": "AB892X", + "89802": "AB892X", + "89803": "AB892X", + "89815": "AB892X", + "89820": "AB892X", + "89821": "AB887X", + "89822": "AB892X", + "89823": "AB887X", + "89824": "AB889X", + "89825": "AB892X", + "89826": "AB892X", + "89828": "AB892X", + "89830": "AB892X", + "89831": "AB892X", + "89832": "AB892X", + "89833": "AB887X", + "89834": "AB892X", + "89835": "AB892X", + "89883": "AB892X", + } +) diff --git a/profiling/list_big.py b/profiling/list_big.py new file mode 100644 index 0000000..2ac9d1f --- /dev/null +++ b/profiling/list_big.py @@ -0,0 +1,4000 @@ +config = some.Structure( + value=set([u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value'])) diff --git a/profiling/list_huge.py b/profiling/list_huge.py new file mode 100644 index 0000000..0f8dfc6 --- /dev/null +++ b/profiling/list_huge.py @@ -0,0 +1,22431 @@ +config = some.Structure( + value=set([u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value', + u'some_rather_long_text_value'])) diff --git a/profiling/mix_big.py b/profiling/mix_big.py new file mode 100644 index 0000000..5aebbf4 --- /dev/null +++ b/profiling/mix_big.py @@ -0,0 +1,1002 @@ +config = some.Structure( + globalMap = { + 103310322020340: [100000031211103,101042000320420,100100001202021,112320301100420,110101024402203,112001202000203,112101112010031,102130400200010,100401014300441,103000401422033], + 110040120003212: [114413100031332,102101001412002,100210000032130,214000110100040,103031420121210,112114222301010,110133330100020,100001001203011,102210220202130,102200120234012], + 244402003102200: [110212012114431,100001140020000,100012101223021,110031301200114,114002020044120,100021004302202,102202200240222,114102010220042,102021301441201,104103102103201], + 122013242003223: [100014100100001,102100004130301,111120004100414,101034024000101,100021424301033,102003004003400,103340410140122,100102114100420,111012202111021,100103144302200], + 1120010021223330: [110332202020000,104120130021200,112421004012141,111100220022101,100021104201130,102224410201003,110030021010001,101300401002320,112001321113132,101110434020010], + 214100003030021: [102122000214201,100242141004122,102024240221040,110320011200230,100011114300334,102303004110022,100110201042101,110134201140010,112101044000202,100040024340013], + 1000220132200020: [102231130213210,103214010102022,102000402041014,100043324210140,100023024211011,102404021403141,100010004313001,100003201021001,100122020011232,100121031014040], + 1200041022422001: [100021300101110,103010301402112,100011401031000,100020034100101,100122214300222,103134021420204,102042210220100,100103200021130,103204214043011,103020320102002], + 1000232101122040: [110011414240022,102202310203222,100042001020203,102002320220202,100010044300003,114130210231020,103301410110110,112114324040000,102124031023100,100204104320231], + 110002000000001: [110010000111020,102011041320000,114240012324120,100022010022031,102014140200013,101240110302200,100031204311023,101232001021020,100012121040101,111243002222100], + 200211022142211: [102231130213210,103214010102022,100043324210140,102324014112020,102022004012201,100023024211011,111130210020000,102404021403141,100003201021001,100122020011232], + 114121130201204: [100040031020241,101100104000222,102324141000002,101010234004042,102041224010012,100411400030100,100002000102100,114340102322021,112033124022002,102120221120200], + 104101002123040: [100032320000112,103140011442322,100312120141341,111144020011120,112142204020032,110044031204131,114012010020012,100001420412010,100102110020102,103022000123142], + 241101103112120: [110333404433042,112240002043300,110021100132240,103104221443021,101100304000101,100202210410011,114402212310021,102411011111011,103020141414101,100113001040420], + 1004020030320422: [100022214203010,110310011234031,110123111300000,100020031041304,102120004000101,102020002000420,110100302010110,100422020030044,101220100303222,100002220411002], + 1041010100001110: [111124004101012,114103220220104,102120004001310,102430121110340,101021204000200,112141104020201,101200111020111,110001200422320,103210114021430,114223242332100], + 121103011132000: [110021104200001,110441140102024,111140124100100,110310020040401,100002024303323,110030002130201,102103320232241,110302000400221,110111001302000,110210304220000], + 1042022101004111: [110021104200001,111140124100100,110031301200114,102103320232241,110302000400221,110111001302000,110210304220000,102033124000111,111000212204213,110010324410130], + 102220010222003: [114003212210013,110302012103114,103023101400002,110010120440200,110024140022040,100002100100320,110100034200300,100401201010220,103200024021204,102100204000234], + 1442130103121040: [114413100031332,112121020204344,102211030203010,100210000032130,214000110100040,103031420121210,112114222301010,100001001203011,114214404142034,102210220202130], + 110204013021024: [110301402000211,103030201402004,110420104221220,103200004030020,100320014310021,102000110221110,110240214432004,102122141142000,103041204010000,114432234113040], + 100001440133234: [102111040210242,114110000002430,102010011412143,100424220032043,114013422300032,102021004001004,100131414303044,100201010110320,100000221030033,110101101120302], + 114002033000020: [100001121002141,102000040201003,101132131221321,100004440004031,102002011033030,110310300003402,110220022132003,101001000302103,110044112100220,100010120031210], + 112123022000131: [100304201000221,100112021020320,103010001422020,102300124023122,114221004100020,100002100124101,102304100210334,100403210010142,112003100241220,102204304000304], + 1143001230040001: [101033124003122,100313144100202,103201004024412,114014222302011,103011020110211,110203420111140,111003412201430,101411214000203,110222422042203], + 1002403200000231: [100122004300410,102140014001101,102000104012232,112400202020003,102000224000011,114122134140002,102101010202004,114400202310210,100042030201341,112233332034000], + 1003123041101031: [110043132100300,102220120203200,100002004201122,110132031134031,1320303202002000,1321200010022312,110130330012140,114102134002330,140403400240000,100003230110201], + 242220101103400: [111130112100210,102202200240222,110131044200121,100100004102234,110223332120231,100001024301322,114013044102010,114220114140122,101023021034304,110200210110130], + 121030040400021: [110011011212100,101134030011000,103220211421421,110123230124040,131000001020102,112200412033030,110420001000202,100102110402220,110412310030001,114012022302022], + 100104011300401: [110320414420310,110100100101041,100420124100211,103010211222002,101040120320230,110013021300010,101043234000412,101220000040002,100422001002123,114010010010002], + 1004003211220032: [102400100230000,101100300302102,114120420223002,100002210201212,102302020212101,112410424012010,100030004104210,103030201434002,110232110004010,103021201430000], + 223011102020040: [110012420131001,100132040031022,100020310000200,100220004030002,110020002003334,110014000442004,101441204020001,102014201411102,103231320100042,104121201242032], + 100200110422111: [103100221440010,114003344011001,100021101000000,102140000212141,101014201030204,101203001010111,102424114020143,100031201030102,101041001003300,114012444020220], + 134300111030221: [112100124023402,101020044011003,100002414210010,102010042000041,102242204040102,100021014100124,100130244302034,100122040012210,100014010104404,101020104000001], + 114001000330100: [401142101000022,400114001102410,102100000012031,431232000323104,1012100023110102,232023302143031,120200122422404,1040100003200241,111414004440203,1020220210340010], + 211222012120321: [112000112000031,100121214300000,102123214020000,102022124012030,114002320022312], + 1122000200402140: [102401141113031,103042420143020,102304314110202,110210400002012,113032012204012,112310002020302,100204311000400,100403012200201,112002111121013,114211100001224], + 332000024200013: [102120010220042,110103312142034,102210210312302,101120100320100,114140014100000,102110004002301,100130020001030,112022100213011,100101231202322,111210020001013], + 120041442412123: [102133011413110,111001200041102,101223020300040,102034324000220,100210000032400,101230020303000,111340130010314,110200422121211,110214220002020,112220414010040], + 1011011320300100: [100102024301030,100111134302041,100112234000041,110004244214343,101002101020003,102214021120301,114221224100022,101330210310300,112003021111000,102012141134211], + 220020021000101: [100301001000202,104101112102403,100023121223031,114201432320014,120000002023011,102133120200123,101014020301201,102000031130401,101010111002141,114123124143310], + 1024011342000021: [102001001130100,111204203012002,124020002020003,122222120003214,133332002141010,144000013213001,124010030100142,112310202021010,110014020020011,100140044020011], + 1131011002310011: [102230040200031,110122001010214,114043140010022,102101204000010,110022300420031,100100401040001,114230230000123,100222024320003,103323001400013,114013012300240], + 1142024120224002: [102203344011410,100021324100000,102103430210003,100012014300120,102414014022212,102012220241003,101004411032102,101430211012120,100204021000012,103242044020102], + 1100004410231120: [110013202003320,101031241000010,102120231343224,110030332100203,100314114322101,114404232310120,103100034001310,114002202210331,100031301020100,110111032140220], + 1440220030001122: [114010330030011,103021220104200,101010020320000,112000210211020,100010324210003,101000000343443,110002400011111,100402132200000,111100300024000,103144040104204], + 121414301110004: [110144240011020,110413401240204,112000244001222,114441114123013,103220211421421,114000012334102,101000014012442,100312401002102,111022210021013,103110001420121], + 130004004220120: [111240340004003,102021024000010,111101222244030,112011012004300,102300010242330,102000401120420,102004012043122,114011102210402,100120001014040,114300100000041], + 1013303000401020: [101000024004442,100002100000100,110130030020000], + 220041302111231: [100002014200331,100034244210020,102012004000003,100411000030110,102041201121230,103011014042120,100000030120242,102110400210023,101012204221200,111212422222300], + 1000031031200013: [101302134233230,100000130010033,101030404212000,114102224000201,100022021041122,100020001042002,100013011020311,100120041020012,102012204000242,114143024003322], + 1000303301100221: [111333104124202,101000304014100,100040011023101,110301030010140,104100002101431,101123232010002,114421242204443,110100222001100,103102000121300,110010331230210], + 1410211342331412: [111002100000102,114021010040140,114222302321101,102101024002121,110014024202014,110220130100010,100020011030330,102404221402210,110203022032320,101222014230110], + 1411020122202044: [100141401021003,102010000231120,101000400320211,101001010300214,103010020142023,110132002212113,110010100040100,102101002002002,111020302232033,110224030114311], + 101010042001102: [101221020040220,100103104302044,101041030320401,102141212000200,101203121020430,102020004000014,100000211023014,114144014122041,100201111002224,101410304041000], + 204204011102020: [100212030414010,101400004022210,102031021441200,101200020303202,102301324112020,111340300010010,102013224003020,103013020123142,102240344041020,102140202001100], + 240000420312002: [110002004410202,102103114000024,102240221000001,112041002002124,114000024101102,140343100002103,400200234320200,100020124204330,100001424102041,100100021040230], + 1030000001422430: [102343230224321,103211200100400,102112231020231,100022004300020,102320000240102,100042144200000,102030304001101,100020420121003,103020004011414,100001104301200], + 1104234221030010: [110000322130121,101023001002020,111300222202234,100200001210021,103204230111030,104130020011020,101114422122000,102001314013400,114110414140400,111201100011141], + 121341130003000: [111102004100101,102021100220101,114000040010421,112042110220004,100000214240410,100433201004014,102301102004413,102003000220111,102010100204023,102414040230400], + 100101220022002: [100010024102110,101041200320012,114303400002201,110204211000331,112121014003422,114430102311021,100240444100022,103004411424400,111014002140322], + 1023303420422001: [100043104240004,110002034200042,100001240100033,114100304002030,102100001340122,112030010234104,103414101212410,100123021223100,112302011102312,101020030343002], + 101114102124321: [110403244220202,103113014002100,110120400402324,100402340010310,112010020211000,100102200000211,103030201240100,102300210210222,114100332340213,111031030024010], + 1422302020100030: [114020000030002,114031000022030,100201211003004,102014002000401,103103241421322,114121012340044,102000400240203,102104304023201,103310300140324,100002224244002], + 1121202400231120: [101211201202134,103120104030100,100004000100101,102020030220200,110031404423144,110003434410403,111110000014401,100000204312321,101004000304012,110300121220201], + 1042001221000013: [114032104100141,101213114040141,102210101002412,111140100011101,110122421241103,112001144002010,101013030304101,100012011022000,102000004000013,102021241324040], + 1102433033042110: [110104112010103,111102004100101,100122004300410,102202414041044,102140014001101,102000104012232,102021100220101,114443330001442,100230120001003,114000040010421], + 100103201011144: [110102401201204,102400100230000,100212030414010,101200020303202,114120420223002,102013224003020,100002210201212,103013020123142,102302020212101,114303340000001], + 240343043023011: [110120144200000,114022412330004,101200221022044,110241112020204,100002004104004,102100224000210,102310140240012,100014204201000,102103321411004,100400001001300], + 1020301032424304: [101302134233230,100000130010033,101030404212000,114102224000201,100431000032001,100020001042002,100013011020311,102103331400000,100120041020012,100020001041231], + 114200022220040: [100014100100001,102100004130301,111120004100414,101034024000101,101243024011000,103340410140122,100010021221221,111012202111021,100103144302200,101414100300221], + 142041243300010: [102102002002242,101130104022002,101230331020012,100004244210201,102420124024204,122312222240401,102041014011340,110200130004300,100140101012000,101400000302141], + 1002203102111022: [100434000032200,110004020020022,114032412303041,112000301122111,102020130212402,100010001020000,200000020021022,114321212322303,112302112002211,114202002333330], + 1110102121041413: [101012310301211,103112200123144,114242304004011,102302200241241,110001420021023,110201040003402,112301421130130,110020012100302,114412202320010,110021030030202], + 114020200220012: [102010114022011,103340041403223,114002200000421,101020321002002,114302210010001,114030004104220,100104004301000,102443211401140,102301041000014,100001111201214], + 202011212123200: [102203301123001,103210400110122,101112020300011,114104302341000,100400201010000,102244400201444,101010001000121,102304000220032,102002131132000,100000031024222], + 201032103003132: [110212041114210,113210300100002,112404024011000,102131034000220,111212124130140,101002014013010,103402020120010,112110100230023,112003044002004,103020200102200], + 120222032001012: [110121100004131,111400214442024,111122200021102,101041100300001,102140011440001,101011220342010,110200004221020,103114211441300,110000222010004,100114000101041], + 1100013040001020: [100003031030034,101001044211204,102100010233022,102120400212001,114313022302101,103001324000110,100002014200021,102300401001010,103212320212011,111120034400000], + 1001031021300022: [102000020220000,101020104000040,114412142320040,100003044100101,114012402332300,102220211122102,101010110302010,100032121020101,100013224313301,100012244240030], + 124000010122242: [100032320000112,103140011442322,100312120141341,111144020011120,112142204020032,110044031204131,114012010020012,100001420412010,100102110020102,102002204001140], + 1121211020204132: [110020301320101,102014001130210,110401041140300,110002302201420,102202001120002,110200010003201,102421004041011,102240040202421,101001110300111,100130004300103], + 121320202004301: [111014240041102,101100004200110,112021221130424,112200041103002,110400040402041,112001011112202,100112004304314,100232041001122,100223030001010,100104231000300], + 1024242230240244: [110322104424202,101202421002031,102102220312102,103004204021310,112220102043102,110012310020200,102030130241300,103030120100220,100232224340041,112400002011010], + 1002100010130110: [101400001011042,100002011020211,100100110010010,111110002213142,100002131030310,111102214100400,103220201402330,102321000221140,103113124030200,102110300311400], + 200010402222410: [101210320301302,102100221340112,100114104101001,114002244103320,101023221000031,101400014040400,102012034000402,114221004002212,102100122002001,101000011021414], + 112300020202111: [103141411420221,122102400312000,110002100110002,1340024302404122,100002001043010,113110330121030,410020013004430,1002300040412102,1210020204140003,123211320000102], + 100102203210034: [102023021100022,111200302222011,112040241120204,111000022200000,100010011232324,110220030000133,110000330430311,101211221014003,103111230120100,102221220200021], + 1021001032000012: [102020010203200,100011144312020,102011204001010,102001410221023,110130201302200,103041021430301,101100440320434,114000402211404,101000100302003,110000030430422], + 1031102424140120: [100011010414200,111121102240240,102002121101110,102403100202003,110000100041101,100400000010033,100101211001320,101141020321000,103224101400400,102000002043020], + 102001021434201: [110131122012210,114010200040441,110032014420232,100000344100100,111304022202211,102302011002003,102011021121200,100012441030002,110222042022111,103131004002200], + 220100132400104: [1010400230221020,111320012221132,102302144110440,114140004123122,102143202000400,111020002202333,101321311004010,102110241342210,114122302311011,100002320411400], + 1110121023020002: [100022041001002,111240340004003,111101222244030,114032424122040,112011012004300,101021401003220,100301020420101,102002202000000,100022024100041,102010410213111], + 1042030001044121: [101230040301234,110033032100000,102303014024221,100100224304110,100400432200321,100020200012311,114140144122230,101400201102014,100000020004004,101040040303102], + 1100100224104011: [111130112100210,102202200240222,110131044200121,100100004102234,101023014004000,110223332120231,100001024301322,114013044102010,114220114140122,110200210110130], + 212002042300000: [100030220100110,110011202100142,112400102013231,114012002212100,100002114314022,114203110001031,112030122000211,111004012200210,100413131013301,110001102103432], + 221001240043040: [100420021010013,112101302302202,102212011120200,102344111104233,100432104320110,114021014020000,102121321340000,114200214002024,100111221011100,100023104101340], + 1040021200420124: [100042111220111,112220100202000,100042041220010,100403211010100,103240301400123,114102210214041,100021300103041,101010204000242,111334004121414,114101000213410], + 1101110030041022: [112013300240132,114303044030300,102340044111034,100110021021010,120003030010112,114200212320001,101020240313001,102330220242002,121400042034110,100033201030040], + 1030000302042203: [102110231441040,100113214302002,110000002133140,101233341022410,103021000144000,100100124100031,100040204240000,114100012313002,114440440000034,120240000020201], + 1403121230220020: [110200400000020,100324140141402,100002204340200,110000410001034,111140000000000,103102224034002,110022002120332,111110230014001,110020041310021,110001001200323], + 203110414022010: [111240220002100,110030344201413,101001014001021,100103224301304,114000100020200,102102100231000,114040202330200,100410331002222,100032204311200,102202111110404], + 133032004200001: [110314100012011,111020422203010,103121124002320,102240300202212,114140422203401,110210420000001,102210331401030,101102104000100,102031010200122,111104202112001], + 1120000102422014: [102140211342044,110020301220411,110100200004404,110131142010001,101032441003040,112004400210201,110004102230402,112021004020000,101012004001204,110420001344420], + 1000030222010034: [100320031001240,102104320220212,102100200232044,102434104021201,102300004022020,103003301240122,100210024101140,112220011101022,101000130304001,103020024043010], + 300210002300114: [112100021100243,101123001100112,112003002001002,111000200012220,102120100230203,100111124101112,112001010233001,103313021401232,110430034224001,114110200221240], + 1421020010140012: [110010002014100,112030001120220,114231034004040,100100301202103,110301021331320,112001100232420,114020244023001,110342014420100,110200402220240,100114200402104], + 300310000040102: [110301222101110,102023301102400,102012204010044,104120110010402,111010214402000,110401440001204,110204310112224,110303104423010,110340022023321,114010200012200], + 101010002031100: [110324020012330,100001134302201,102100011402012,100020221031000,102032220220223,114042004020130,114030400021223,102022021100102,103301304031211,102000004013440], + 1032221241200404: [104120011242011,110020002104100,102000301101102,111122200021102,114032234033303,100000020201032,112011204004112,100003000002034,110102022000200,102200034040443], + 1131211404001020: [110200100002031,101420310301020,100020330100100,1002443410030003,111103224103001,100011231042030,102100141413100,102110021342213,112002310211210,100010031020102], + 132013120010104: [111300232202103,102301401002404,110122120100022,102012004010000,102400100220000,102001104012021,100242444300104,102002104014323,100401241010122,100010010102122], + 130000310202012: [114200044114004,102202010204130,100220101204311,100002000102100,102100430233212,103003210141014,110421222011222,100201000410010,112110202014400,100400030013200], + 1111023010042112: [100000201220420,114000030021040,101002011020001,113141112413242,102021111130104,110401030101001,102201214011331,100013011043231,102031114002042,112302012020342], + 121010001111310: [101400220300033,100012021032040,102001130224032,100012021040320,102130224023220,102100401143124,100010001030140,102110101410144,114142204121324,112102421102022], + 1113001011001223: [110202400003213,114112014140000,110001012101334,114200124000134,100001114302424,101222134011002,100003011231420,103230231200010,100431031014023,100120120401041], + 142034000000112: [100310304310342,100010041031020,100042400001023,112402000200101,100020201221000,101010020301243,102030001103000,100040021031201,111010130022401,112140214000020], + 1012401424032042: [102401121113302,111201210000103,100101101010100,101320040302031,114010102300010,102321044112101,102000014002000,101034014011332,101203011023020,100021231020200], + 1103400010414230: [102010114022011,103340041403223,114302210010001,114030004104220,102443211401140,100000221020014,102003224000022,100010031222001,103001114001210,100001111201214], + 1400000301203010: [114122134140002,103012011434022,101032010342004,102322330243202,103101411424112,100100114103001,102134131144121,114030222300123,102102301021403,114103402201140], + 214024214401412: [102220242000201,103010021410203,101000304214111,102120040200200,103202220100114,111100132103413,112203220204012,100113040003021,100010204200010,102410134022300], + 1221011020200210: [110041030411301,110001041213031,101110044200100,102411000200000,110414300030001,100030020011022,114100122342002,111202012222402,110033041200104,102000221442214], + 1000120020110040: [110200411140130,110114120120100,103124210100201,111014200024034,102301002004242,112020014000340,110021404214210,101003014210212,100130220400031,100210024300001], + 201001342101001: [102001444000222,101400134043222,100010400013202,114340312301134,114310242320310,102110021401100,100113201011032,102230000204000,103102044031002,100011421002120], + 1000000133120020: [110230000000002,110220301202400,101003140322000,110401001002400,110210024220020,114201142324042,100401424300314,102213401111223,100040120000031,102002104011244], + 101400102142302: [100004211221210,110201001212001,110200134240420,110403221000002,101201304200320,114022042302201,112002320212232,100002210413202,103140021401211,102404042001400], + 100203202010202: [101000114000402,100043100123004,102014014000100,112212042024100,112410322024122,102300110221100,110002332102000,112001111111212,100020104300430,112041020221402], + 1011401013024410: [114444244144110,114201004110120,114033234032101,100412114304000,103001020120202,101004411032102,101000020302400,102021014012210,102244221114031,112400000200011], + 131012202321232: [110041030411301,110001041213031,103301210142043,100002024200142,101110044200100,102411000200000,110414300030001,100030020011022,100400014321101,114100122342002], + 100303010210441: [102304034110400,100043010120010,102101124001310,110030110122402,102430300201034,100004121030301,102143432000102,101031001004201,114001110033210,110120011014412], + 1111011030001020: [100032041021210,110001041213031,101110044200100,110414300030001,100030020011022,111202012222402,102000221442214,102040041320010,102402104022000,103203401400132], + 1420144022031000: [101240220300022,102200130202201,100002010014040,100022000410041,103020000102011,103001031420203,102301324112020,101040421033204,103130011441212,102240344041020], + 104012440012200: [103000001432331,110131110401120,103000004011102,100120041014034,112111110422120,102130300200301,100121100002240,110224032100120,101104220322100,100001001201301], + 120311002000121: [101220014012231,100104024303320,114422004110130,112210132031001,102010310213001,103244320114100,103422430124013,100121424231222], + 1002120002022122: [101201220300012,101232104042101,101220404012304,101000304000400,102020204010341,112020100202034,100140410020232,101221004040204,100412414304143,102110404001401], + 1040331220001000: [102041310200042,110301030010140,104100002101431,110221000111302,101010001002000,110022140120012,111330020002213,102011440201423,114011212320331,100002204310140], + 142030323441430: [110020120023302,100043120003103,110002000410040,100433001014104,100000004102121,101022411030002,102000021442024,100030314100004,100404130020000,110400302114103], + 1020000001100400: [110001202000032,100024204211200,114200004110244,114230412332011,101210101010023,114422114140221,100001211042341,114032104123010,114303122321110,114330204034200], + 1001130242231402: [100042320001030,110024001010110,100100014300230,102043104010014,100001004300242,111120044100110,102200201110443,114240314000100,101002411030000,102002324011002], + 1014202010302102: [114200212322001,100401210020002,112210322040121,100402042200000,100010111022102,102000224000000,100002104302110,101022440300020,101402010301000,100000220111021], + 144100013100013: [114020200020222,114330002323002,110213022100021,102202000240014,114424424144210,101224321014333,102100121342000,102204321003224,111222002224302,114100104030132], + 101213002101214: [114014104033302,102120200221403,110323110104120,102110314001121,101020104000300,114003402300102,111202104100014,112402102021111,103344224020241,101002114000424], + 1012442110402240: [104310001300102,114021132202032,112012004004324,103001314001021,114122220031004,103040024041111,101004004213014,111124002211203,112034420220403,101211231023001], + 1002210200000101: [101232314010241,100301300121100,110042400130000,103020124010320,100021300101201,110230022122031,101000444214021,112102112301130,100414004300100,112102232300222], + 102400210400022: [110010334200041,100001024102001,321114010100340,102322101000200,102110100322014,110413131000201,100000100000432,101020021114310,114200104110001,100010314202003], + 1043003020000104: [114101024120020,102004011440212,100000001021013,100011204300012,100101234330123,110024000432310,102012101443110,110032220022103,102102104000102,101210031201114], + 1243002022101103: [110203120112002,110000002100100,102221410200012,110213401202110,102300104113403,102213224110010,102300004112300,102420024020120,100040020001022,102141140210200], + 1421204200010112: [100140101044224,101120004023340,103040031403031,101030014001004,102012421412000,100010044300131,111010130002222,110200300000010,110144102001321,100020304102100], + 1003013101233010: [102400111402142,100040240004024,100010000002400,141030301403400,100000024100211,103224200113121,110140101300004,120020211120020,110230010010142,101002041000124], + 101432210141203: [100310120141002,102324014112020,100301421002002,102404021403141,103022021431010,103200020111014,100010004313001,103104200210410,100002200410030,100121031014040], + 1104003002031130: [102420020200202,1023413000203201], + 112011130023123: [101020014011102], + 1102310021242142: [100022041001002,111240340004003,102021024000010,111101222244030,114032424122040,112011012004300,101021401003220,102000401120420,102010410213111,102004012043122], + 1002120410241114: [100222000144103,101240000310400,114022002211402,102311020240221,110211000004002,114101402200030,100000034200300,100010124300001,114200022322000,103133001441320], + 1022312211002000: [102123140310122,110101214402023,110400014224001,101410030330122,111000144410222,100040001022000,100222404342030,112204022020043,112320100202120,110222241300101], + 1402011002013421: [101043042401310,104001222102120,111412020003222,101113012101010,111212022200012,110023132100402,102022102010211,110231202040203,112112410232001,100021220002020], + 1010121032032211: [100002024340032,110000011220401,102112340210300,114100214000010,100000104201200,103000304010211,100010000002132,114100042311312,101000014001020,103014141222013], + 1020030002101022: [102040431121110,100400002201113,114111100021420,112024212301420,100300310140241,100240134323001,102111024000402,102001011100100,114402104142102,103312241402001], + 1010240311230422: [110200400000020,110203131211112,102301004110004,110021100023210,110402420402001,103122000100403,110000112100402,100002204340200,114103412201420,111140000000000], + 1401004204000003: [102102011412000,114204030210041,110033101044200,114440120000030,101002004014401,100400224323100,102112112004300,102010014001001,102000001440004,110321100402021], + 244331203200002: [101221422120021,100001000002210,100400320033201,100004130002301,101210300302302,102020131413423,110020204200342,100000220011133,102144012001113,114431110001011], + 1130301120301001: [100401140034220,114002002300222,101242004043300,101013111000000,102102131340404,102420041111041,112004312310301,100040121030000,102000404003020,103111020223101], + 1002000403000204: [103343014022202,102003104011000,102220330202001,100022200120040,103002020110334,101021134012211,102140200310400,110010002103002,100220034341000,110200002121242], + 221400100111330: [102031100200300,114102134122020,110024102010002,103010034004303,102023032000000,102101440201242,103000204003200,100021044343014,111433000002144,110001002002424], + 112133300441020: [110120101220000,101040014002010,112001001133213,102000144014000,124204212002003,102311101002242,102110210210004,100000100412410,100012441220104,111032320020122], + 133313202104310: [110013334202122,103330104030103,111200002220003,112043421121002,102212030201100,100111401011110,102010341440030,100001120100002,114001000024011,101021024012041], + 100143040212102: [100422314300200,101210241204043,100123011004113,100420001002101,101134224001001,101021204000200,102321234111310,101200111020111,102000024000002,111122222240232], + 1432344120130401: [101001040340004,101013004002011,112022334022101,101011324004222,101410401010030,103210241422022,103240001403000,102202204040220,102121010212140,110020124200230], + 1100030203241342: [100440104303400,102122000214201,102220241100202,102024240221040,110320011200230,100342024100204,101422034042201,100011114300334,102300001002140,110040122000002], + 1011102003042024: [104110021244203,102224101113104,102103022002001,102102224000012,102100102001032,100142431013000,101000031001011,101100001102230,101010130321200,114004322330012], + 300210041431432: [103114001441122,100422004320024,114211110023303,111000302230100,114044144020400,103001101422012,4000113102314022,100022204104123,1400100000042343,1002411322210040], + 241241343121111: [102021001132040,100032201024101,102301004110004,110402420402001,110000112100402,110021021210300,110404000000012,102000101120123,110221022101104,110023100402320], + 1100142404020120: [101210144014403,102111420233012,110000020022324,100020231201012,102210424042300,110220032120121,102130240221020,100101101020002,114442102312001,100030201024402], + 110001043032202: [114240012324120,101022011003022,101240101000020,100003101003001,102313100240202,102000014002101,102110422004402,102100411340400,101300414221100,114020210020424], + 1100103200140000: [110013202003320,101031241000010,102120231343224,110030332100203,114404232310120,103100034001310,114002202210331,100031301020100,110111032140220,100020010200022], + 212420003003124: [103000001432331,110131110401120,112111110422120,100121100002240,110011010001020,100001004340202,100220100432201,101000140200002,110140001201040,110001041310202], + 1041144140041401: [111120214100003,100014131222022,103110114004210,113002020130400,112012112001000,102101404000324,101142141144040,100101231202210,100003001223010,103142204001221], + 201023043021424: [103001024002110,100231114320100,100001000002210,101210300302302,110100012120201,102020131413423,110020204200342,100000220011133,114013012240011,100010104312120], + 1011412300010442: [110104112010103,111102004100101,102202414041044,102000104012232,102021100220101,114443330001442,100230120001003,112042110220004,112203221102231,114022400020320], + 1130200034001002: [112010102000041,103210304032003,102130224131022,100000201034001,110400011140402,112011220222001,111230204100010,110023022130322,110022222231002,103110100210212], + 101001320111143: [114000044020204,102320000221020,110142020400012,103131420221204,102120141343312,114321114032200,100142011022211,114230344103210,100030020104423,100102011010000], + 241102301203043: [111000010041300,112000002003301,100200221000243,102400044023410,110423034242000,100104100412020,101020031030240,111204000003031,100012004110024,102142000210040], + 100021101400201: [110000101304203,104121412100011,110040020001022,101104020300301,102101004000011,101401001010021,101200200300020,102011200213421,102011021411140,100000001020100], + 1041203303120002: [110010334200041,100001024102001,102110100322014,110413131000201,110020104210120,101020021114310,114203002330010,114200104110001,100010314202003,101013220301033], + 122400010411021: [103100221440010,114003344011001,100021101000000,101014201030204,101203001010111,100031201030102,101041001003300,114012444020220,101414214021020,114412010002302], + 1143000322124010: [110041042000232,101002400343001,100032400410212,101202321024330,102303000241003,101000001002320,101310201000040,102004341420021,100012101001312,102010334000140], + 1040230013042024: [102302440220001,100104400403240,100020111221020,110010122102321,110002322101200,102220124000003,101020201003002,100230300001042,100311334020020,112400022020023], + 222004201002140: [110313002103302,112424204040112,101000014000004,101142310014123,101430401010120,110102410400023,102120220310102,101010200311020,111211214133000,110304102022001], + 1042000233033310: [101000004000241,100120000410020,102311000240202], + 1000002141204230: [111240220002100,110030344201413,101001014001021,100103224301304,114000100020200,102102100231000,114040202330200,100410331002222,100032204311200,102202111110404], + 134224341021441: [101210320301302,100440024301100,100114104101001,101023221000031,101400014040400,102012034000402,103341124011404,102100122002001,101000011021414,114101000221221], + 212200220320113: [114423002314000,114040002210432,100010040122204,103314044033003,114102224104002,102001420220112,114422404110312,102403144000120,101033041032041,101010010300020], + 110100002004320: [101000040320021,114002210021300,101401300300011,100032001041230,100141120014242,113000201000000,100142114304120,103031014003010,101001021032110,114400404121002], + 1411200112202131: [110030002000422,103100014031411,110000300424304,100032121024110,100011004343022,110401140004202,110040002034100,102402330230011,102022400211311,110203210002230], + 330234311421104: [110443010102111,111320004131241,102020101324002,102401030202031,100210031004220,114140304122040,111321012222400,102000104002003,101223000300000,114201100210120], + 210040200410202: [110010000111020,100430014323000,102011041320000,112100021100243,101240110302200,100012121040101,111243002222100,100020411020310,102121401402131,114030012302003], + 100000040042044: [110101210013000,100404121014002,101240220300022,110120020002304,100011000202214,100000024100000,110212214400114,110012101102100,102102304001200,100010040001210], + 1224441200202014: [111320012221132,102302144110440,102143202000400,111020002202333,101321311004010,102110241342210,100002320411400,114201000004122,100143034304100,114021002331014], + 140222000310233: [104111102100000,102012201321104,101021004000000,110130042014110,103012301401041,100022130100210,100001020002400,103042224001110,111000230041031,112204300204013], + 130101221040100: [110410412110241,100130124030404,101021121112112,110101002012003,111131132101000,102300131102042,111121230030002], + 1033022310023442: [104120001244220,102202300114223,102310000240000,110301034241300,120440001302100,122032310023401,110113002140210,114331204032013,112042402000000,100002010000241], + 100204342220311: [100010014100021,110403241001010,100101334233020,103120110111300,103202420103102,103004330103000,102002424001223], + 100044003200110: [100021400101221,102241341113010,102300020241001,114100124100413,104130301242304,101001114012114,101141400302200,100002044101122,103342424024214,100100021040420], + 1002131022022212: [110200400000020,100324140141402,100002204340200,110000410001034,111140000000000,110022002120332,111110230014001,100210200034304,102032020214001,100301101000021], + 122003200104101: [110033000022043,110100200030100,104412212102010,101230004040022,100000411231000,103140021211010,110132020031210,100020140121034,102340211000200,102300231000210], + 112200012414342: [140400400201014,110001212100204,103220130211414,120020020010400,101100211042114,121022000104032,112101102012030,111201122241213,142100040004101,100002244100310], + 1014202212322031: [100021000104004,100002200022012,111140204103210,140004010302423,114200320003120,100200113201000,141220400002200,100044231103400,100411033204412,110000001210210], + 130211322041021: [110311022103222,110302002100013,100210240412200,100000104343000,101140211100200,112301000204230,112202101100120,100000110412000,100034010000110,110402404222022], + 132200002220122: [102100441341013,101440004042202,114201102342110,100100204101010,114101200210030,100104004100400,102002331440012,101223301020130,112100002302240,101430001014014], + 110230202100302: [102012001130022,110040322000012,100331124310011,114102222344020,101042020300000,101220201204012,110042104411102,102142101121010,103200211200414,102111111121420], + 1100244431221122: [100032000002120,102313234112000,102000000220040,111101100020030,102014024011240,112022330222011,100030201220012,100203401002120,100404024103100,103144000112000], + 112120203210001: [101241200300411,110111001300001,110200012120122,114000102330022,114021104100400,110000430001014,101214400301420,112420200202001,110122201304044,112000004001011], + 1010021212012040: [110101114200020,102144201343034,112132120202010,110002201320001,100430010431044,111020122230001,103040201222041,110111221000100,102341131103201,102100204000340], + 1101003002401011: [100000041032002,141000211410012,110101322000312,103002420100102,114000204013024,110101221001401,111044114411101,103423300120104,110412140000033,103021100002140], + 302220212000441: [110023342101220,101001421031220,100021004310222,112220322030220,110202222043022,110313312021120,102223400201104,100220214333200,110330234422000,111000034110311], + 120200310232204: [112000210212000,100112001014144,103310140140002,101310340314200,142012003022120,111130114102040,100111100000100,102322104114020,100010131001221,100013201220121], + 1020004042003403: [100110400404220,114221032331220,103200104032220,100212031002000,112002004002011,103100024001400,112400014020404,102000020201240,101012004044003,102021010212032], + 1114040203024320: [110020120040121,110000100022040,111021030042411,114004142244000,110131011000142,102401010202301,110202012020000,114240000001020,111110004101041,114132022312030], + 1141211203210210: [110301301232014,121202234011000,102140002000000,102124021023300,112444304040204,122022100000222,100003024211200,102102402003021,114302402321024,110202020004003], + 132004224340023: [102002120203400,102000221101002,102000431130020,103120004004010,102143000210010,111104404100200,114432224142000,100202234320210,102330124110411,102112400210210], + 124200241310040: [110001121012020,114244444114012,110404002114232,110032330032030,110032230140020,112224000203234,100404112201001,114141112324244,100111040404120,113431040101200], + 130014011300003: [110310044430300,101010021020013,110200020001000,100420104100222,100401022201011,100030111042110,110032110010141,103302000142020,102010321104413,100102210402003], + 134414300403411: [100002021021021,102200000200300,100000101040020,100110040013320,114023012303230,102402000202120,112442220201020,110002100012000,103211400100200,102132300233002], + 140221020202033: [100003104342121,100400414321103,102132204131302,110020034203040,100032304202003,101420300301103,101010231112144,111000100003022,100113020400211,100022030414220], + 1002220010000302: [103112010213010,112200410200142,101212000301013,111400002102112,100034100124302,1320102201231021,100000211020034,100000040413022,101000000323000,100011221224211], + 103201211120304: [110441234224400,110030002000422,103100014031411,110000300424304,100032121024110,100011004343022,110013122130200,110401140004202,114020204102020,102402330230011], + 1000304403212210: [103122020213112,114101100211240,114122134140002,103012011434022,101032010342004,114102102344110,114010002300003,100112110020301,100000004102124,100022301000112], + 1001320110010041: [110011011212100,110123230124040,131000001020102,110420001000202,110412310030001,114012022302022,101042024210020,102202144030004,102141111100102,111030340040341], + 1002002040323201: [102100224000210,102400100230000,102114022004023,102031001411010,102030000223420,102031021441200,102300031004340,100213310112333,101200020303202,102013224003020], + 1022232012234013: [101011010320431,103041414001042,102441324022342,100002004344013,103220000104122,101401030302440,102040124010141,102314221101100,114240004002100,103131401421331], + 1040202023040201: [104132340011314,102203304123030,114012040020310,103132004002242,110000212104130,110200200004002,114131040224332,100123020032031,121002023311103,100021124203441], + 1002440332021113: [102004010220020,111000010041300,112000002003301,100200221000243,102400044023410,110423034242000,111204000003031,100012004110024,102142000210040,102320214110001], + 111301001000030: [110204004430204,110300011230013,102100400222242,102122114003140,100002021032001,102011404010000,100000011220004,114111002340233,110000210004001,102100324001200], + 232110121020324: [110020301220324,100041000010302,102020100243032,100031001020040,100104001041200,102012200202303,101110404021211,103110041442122,114210400000112,114042014102321], + 210031213113040: [103242420100012,101400004022112,100100210000011,103002221400000,102022030241032,102200000200201,110020402004210,103110020210000,102120124004021,100022141030334], + 1040100401210131: [102420101111121,102101244022242,103222000100010,102013131134030,102004004010011,114101042313041,121211001014412,111012222200402,103300221402010,114021004010042], + 1000130012301000: [102021001132040,102301004110004,110402420402001,110000112100402,110021021210300,110404000000012,102000101120123,110221022101104,110023100402320,100020311220412], + 210104220300403: [100023114341301,111000020010011,110101302141002,110114102004120,103212121402022,103330410111310,110201001200101,100102014001304,102030120200010,101030441032022], + 222012013140120: [110004202003210,100424220032043,102021004001004,100000221030033,110210402031211,112032220240044,111220100010101,101012400340400,100020330410000,112043101112100], + 1011000044400003: [110413304221020,100440000030040,112130010202041,102012404000211,102141010230441,100100341010111,100110214103200,101030320322101,102322121000140,114140002313010], + 1003200020100003: [100442024301200,411231400122100,100400414321103,101024000322432,110302030412400,100110020000040,102132204131302,100010100000320,110020034203040,102014031440442], + 1204020342100023: [110001332120300,110003000420200,110243234240200,110004014411012,114110200212210,112000120232022,102041220200010,100002320113100,112240200202201,110020321120011], + 1221300430001000: [100032041021210,110004301222000,102040011121100,114310000001232,111202012222402,111322234130000,102040041320010,103203401400132,110104002010100,100030024303023], + 114320100101321: [100031300002022,110210020002243,110210022120040,103002044002032,100101020402424,102201112000001,112211120202000,114211040011201,100020100423404,110001222202031], + 112000242020101: [102304341100321,110010202103141,112003234002022], + 1011020202100000: [111443032100000,100010314103002,100240240430022,110310321232001,103221100112240,112000000211220,114022300002101,102323131000021,102020304012021,101020024210020], + 140022010210210: [112300421134001,110321031234422,103021004014220,102023001440404,101023014004000,100020010101201,102312344020020,103210404010101,110124411120222,110100242012000], + 1420302200420011: [102041100200402,112100404000230,110400112021140,110112121002403,110122221240302,102401200230234,102241230200120,110201111200204,110400104222012,110104004202014], + 104210020310230: [101004010304203,114104204002313,114300000002130,131204100021112,121200013012000,102122210230200,103110411212041,110421410100301,110244400212004,113003221014312], + 1011022012144233: [110241142024233,110021104200001,110441140102024,110310020040401,100413311002132,100002024303323,110210301200101,102033124000111,110400241240242,102210101121104], + 1114132034120400: [100441204302021,102100101340232,100011320001003,100000221020200,100200000030010,100200010431000,100003421040000,101012400320022,101332004231001,103300004030100], + 1100123300430003: [102002040220110,102141220210212,111320022200100,102232004040004,111202024134001,100000014100202,111302120011012,102203001120342,101012104001020,103101031440430], + 111031040332200: [100040031020241,101100104000222,102324141000002,101010234004042,102041224010012,114340102322021,110311011330111,103040044010112,102310001100113,102000114010020], + 312000003010222: [100030324200410,102110202001010,100040041020102,114200020003431,114041002212302,101002200343110,103332044032320,100212024322044,100140004102001,114101024122320], + 1201001101040412: [102101004000411,114221312340014,102434121112224,101200210300413,100311204312442,101211204201231,103210021401223,111110014101210,100323140143012,111130412210000], + 120444122021322: [111030212113431,103222004032000,102233034000002,110123011200000,112130004021000,100100200021431,112101202012010,114240004000000,101100304021321,111212024101031], + 1140403033012140: [101214104041040,110104231221040,102012204010044,103101000100022,100020141044111,114200000002420,110401440001204,110204310112224,100042110122000,101021021002110], + 1400100200041100: [100131031020002,102031401100332,100014201021012,110030441223002,103010400120230,114120212310000,102424010230103,114200020210110,103110230210201,101403004020323], + 200111121232200: [102110142004430,114310100014104,102001020200310,110211244400301,102040214001410,111101002240300,112411002010104,110400031142011,103000324042100,101101000300000], + 100124214220001: [100010101043200,100030100004000,102311210221101,100401320020240,110201222120421,101000011020103,114121202312210,110010402103240,102403004020021,110040421210032], + 310304311200040: [102410001402210,110000102100012,102010020223010,102120214001422,100020201221000,114201200004112,101400201100022,102141431343320,110010444410200,102010101130000], + 1100201114304220: [112004300230022,110202001000101,102202101300230,114000102304201,114221124140000], + 1411020200331011: [110200002031302,102002020243020,102040021121030,100311314310000,100000204130001,102041130200101,100412441010422,100220031001210,101010200312020,101040204210210], + 1044022301110402: [114000000032100,110140102142200,100122124300010,100110034101010,110410224241010,111300402201232,111011100022010,100400444100202,102004000201030,112020401130100], + 1040020040030020: [112113214020100,102010202004402,111130312211003,103224041400220,100001321032243,102104244000010,101001010300404,103340004020422,102410220200004,103113010102100], + 1032310201201331: [110413304221020,112130010202041,102012404000211,100110214103200,112020112300102,101030320322101,102322121000140,114140002313010,114040124102130,100002001021101], + 122031421042034: [103130314001202,102143314000241,100244210034300,101100322120020,101133040012001,103302320110042,110112324202034,100020321212233,114042324104012,100001101222001], + 1000100024120002: [112241020202432,103341411403412,114100130002210,100100001013001,112401002022010,103000214012340,100004204101200,102400134001010,102001004014032,101321040311120], + 1120432001140211: [114003212210013,110302012103114,103023101400002,110010120440200,110024140022040,100002100100320,110100034200300,100401201010220,103200024021204,102100204000234], + 111402030002020: [100200301002001,114303120004402,100444004302301,101030224211010,112200002010004,102000101410021,112034222002010,103020404002111,112010230210110,100201040012000], + 1010031002102240: [102022000210010,111201240001232,100020301020413,110421202220142,100204314320400,104121410021020,100220004311122,101230130041001,101042034041342,110404034223424], + 110021013020313: [100022010100002,100004100410134,100102014301210,102430144043230,103100130102014,101023321002102,100012030122000,100020200120000,102020024003420,103111230210043], + 132033102211110: [102020221411320,231011321002242,110001332002010,101421101011202,101143201101212,100021341042001,110400131001004,110411200000004,114041104100241,111044212143023], + 131132404101202: [102110141401203,100003021041343,102040034000131,114111302203401,112040041120040,100341001003013,110002341300120,101010011000121,101022140300332,110140412011321], + 1412234223200101: [100020021042003,112404212020403,102100021341110,100002000100120,103031041400001,102022412000010,102300341002000,114002304100240,100100201020222,101000011003244], + 100210020000001: [110011414240022,100000200202012,111142010020301,112114324040000,102124031023100,100204104320231,114002104020100,111222214101043,100010021034000,103132004002020], + 1401424102220030: [110013202003320,101031241000010,102120231343224,110030332100203,114404232310120,103100034001310,114002202210331,100031301020100,110111032140220,100020010200022], + 1000002322230111: [100040301042132,101021104212100,102102241341004,103031000121000,103002020101431,102020300220201,102020431101132,100000041020230,102041021121210,101404104000404], + 1410043040014040: [103104401244021,112031202003020,104114400011000,140402143000011,132344004001203,100210134104040,110422001144121,110000031031240,102110224004010,100022024300010], + 101000122104200: [102041310200042,101000304014100,100040011023101,110301030010140,104100002101431,110221000111302,114101420030202,101123232010002,114421242204443,110100222001100], + 110203202020302: [110041400410001,111010002232002,102402104001124,103210300212001,102023111131000,100000441022011,102012010200010,110441042222033,100040224101210,110320300011130], + 1144000100040220: [110320202023400,111431110000042,100302141003012,102004441124110,103303201400021,114101420030202,100000301221024,101224322120022,110104422010121,110302204433321], + 1032023214001301: [100002100100210,100010001032223,103020031403100,102200401111200,102000430221040,114003104031111,100102020411200,114221030000011,114200302341234,103002110100200], + 1104101020020230: [111220204101421,110042120021013,112200420200200,101001010300011,114012020044224,102122401340101,110021020001220,112001024000200,110112030401012,111112204404021], + 1100032122422030: [100220034322312,100203104322011,100021101021200,112002224004011,103240321400010,102010134012140,111102002240013,102110000210014,111101142110100,101002114000002], + 1141000001411102: [101001040340004,101013004002011,112022334022101,101011324004222,101410401010030,103210241422022,103240001403000,102202204040220,102121010212140,110020124200230], + 200220014302300: [110300100100200,101000224003200,102110140224010,100024101020044,103140024002140,100103240011013,101020120322020,102020011103400,110222000000130,110120021324222], + 1021241323320104: [102404004041224,102200041120220,103220010101140,101140014001001,114101002200223,1034110304101100,110021041330000,114321140000202,121102001120113,103322000111220], + 1140020120203220: [101111140300020,101240301000140,103100014000001,103034130144031,102140200212214,113013120103104,100200241000143,102010031101223,112401102020023,114101320030004], + 1403231230440022: [100223000012020,101123031111011,110014300001402,110120424221121,101022011140403,101031411140420,101030114013043,101042301120010,114423312201001,100104044230000], + 201134111400004: [110113314221413,112004310224204,102304420211002,110403042110030,101221414041100,100032424312011,114112132313033,101110301040312,102204010204023,100220000432400], + 1013111302201242: [103300344012201,100122200012014,102313204114304,100011200201400,100201104224131,100002100204114,102203001300000,102101004001020], + 1001001423001101: [110330400010040,100101231004020,110010100022010,111000100012002,110022140120012,100143040411011,102404404004104,114002202302000,100034000000002,100400100031022], + 120112010202304: [100010104331200,110010104201022,100012031032234,101000204210021,110100121224222,110002142120000,102011011321024,111132300020000,100022301030201,110100100030303], + 201020143002010: [110020100042220,114200302320443,100401111000221,103302010140122,102113101400001,100010001001122,104240202023232,101003114010200,114030204021200,114000022210140], + 123431202011002: [114330014002002,114020024104430,101040214213002,102010210200102,112002040214231,102100222002040,100011004312001,102033041412332,101014240302113,100011021000412], + 1240321040221010: [111311002203000,103301000140120,100332111004200,101033220300404,101440410300202,110013002101010,114401020031002,114020204104030,103243024023000,103232031411102], + 1121243200030001: [110200002031302,102040021121030,100000204130001,100412441010422,101040204210210,100000201034001,112020024000010,102004014011022,100101234002000,101420244021100], + 1021120022012002: [114031102200100,110003010010401,103010010104000,102330030243120,102100100210033,234131201024402,100002200014412,110040311213342,110010102234002,102003144000043], + 1220040022001023: [102000001132113,100041000010302,112004202302034,100042001020203,102002320220202,111321314133000,101131024020440,102432101112141,102100044000000,102104442004300], + 1043404120000203: [101004100331003,112131222010010,103001011400102,102000011102134,100002121032011,114122224003201,112034022311032,111001420021111,111100214400041,112020102002024], + 104301030210000: [114002104014300,102000311102212,100130320031042,102010004040000,112433112020200,112301312020123,100042001020203,112023032000020,102000201101332,102231041120104], + 1210000221304320: [114200110001402], + 1002203002000004: [114022300022421,114401200000003,100241001003002,111310004122000,101221000312044,100400240013333,102030300224002,112010022000304,103100040210040,100210001002200], + 130402220300213: [111231002242010,114042034104243,114000214012010,103232114040140,114010002240111,101020401034001,101440104002230,102440214020040,110004124203400,110102032010323], + 131310204030240: [110212301300020,110210422110113,111322300013200,102202001300342,110010222000110,110433011310111,100210434020011,111212224100024,102030104012411,114200002321340], + 223002002023302: [102231130213210,100043324210140,114113104123200,100020420121003,110002021121023,102300040221403,100001104301200,114121300224141,102301100241002,112002104003412], + 1140102113002221: [100000431020101,100244100032320,111102420023101,110010212101240,104104001243020,100032040000331,104124102100301,110002010440412,110111420033313,103100200103020], + 121211122030300: [101211201202134,103120104030100,100004000100101,102020030220200,110031404423144,110003434410403,111110000014401,101004000304012,114002004100140,100022210410130], + 114010032200111: [102003004000040,102011101131021,100021100013401,111010110042210,100114200020220,114401004122120,110023031204100,102431411400001,114023202330100,102041114040102], + 100000001100202: [100021230411014,110024000412302,111201024101100,100203141001002,102123020230114,114102204121201,114401204141201,101124000330204,114043422212002,100000304310200], + 1043020200022002: [100020220410142,110000412003001,102011331131302,114000230023300,120202201010210,102021204013000,112042024000020,110022100044100,114400200004310,110003000024101], + 132001114401013: [100030200102434,101101230010000,101422401012100,114103204100320,114020012300203,102112410222200,101141041022031,102000044000420,112300001103204,100001001021223], + 1004004102101101: [101100120330110,114141302341111,112400020200104,112212220223012,101002014013300,102100030222104,114113002340212,111203010002220,114104120220323,112134100421303], + 203100022301203: [102401141113031,103042420143020,110210400002012,113032012204012,100204311000400,100403012200201,102011001002000,112002111121013,114211100001224,102112004004002], + 1032011304303210: [112300020201040,111200400003200,100002001003103,110200010000103,100020324204012,102021011130413,102022001131012,102302214110042,112220020202300,111222002220000], + 201102440003011: [102040431121110,101221020040220,114111100021420,112024212301420,102212000200124,100300310140241,100240134323001,100103104302044,102141212000200,102042000222002], + 1003010041242224: [110230000000002,100004414101224,101003140322000,102002001130001,114201142324042,102213401111223,103211104021300,100011200101113,110112030121310,100000100412021], + 101210210122022: [110020301220324,100041000010302,102020100243032,100031001020040,100104001041200,102012200202303,101110404021211,103110041442122,114210400000112,114042014102321], + 112020211002020: [110041030411301,103301210142043,100002024200142,101110044200100,102411000200000,100400014321101,114100122342002,112012020230301,100010101020023,110033041200104], + 1412022323211302: [111120002211010,101201200310001,102023120241131,102020000201200,104103101240204,114241000002004,111232000010230,100424200020200,101020320323422,114220200214400], + 1021100100102111: [112001232000034,102100021341223,114112434000040,121000041000010,114001002304222,110142032004410,102113232001100,100122210400030,101140114002200,110113211003124], + 1101220000020110: [103204214040130,114113104123200,101210210300031,110002021121023,102201100200430,100114021040000,114121300224141,100021020412110,103110000223000,103000210120000], + 132134404311000: [101020100300420,100200021000412,110330000400112,110000000130104,110103041012020,111233314101101,112101100221122,114000212301112,110000020124221,101000200300221], + 111004200220243: [100000210100030,100402042200000,110001440041003,100000220111021,101000430320220,100401022201110,101100001110030,102210011101110,112100302012023,100402000010203], + 1141002203100003: [110013202003320,101031241000010,102120231343224,110030332100203,114404232310120,103100034001310,114002202210331,100031301020100,110111032140220,100020010200022], + 220211320214200: [102121201340001,110400242110410,111302204123234,100030020423044,103013104002044,114211004004210,100034204310001,110011340001104,101023011142204,110034220114031], + 130002321403110: [103020031403100,102200401111200,114003104031111,114200302341234,103202430100244,102302331003300,102320000221020,112131004020212,102003211120021,100033001020140], + 1000212024422033: [100140201011204,104010100010424,103010014013304,102103030201001,101203104200224,100010221031023,100140000024021,101223024200014,112240404012020,101201024203004], + 113101010422232: [114130012310000,102112432004423,100243120430140,112214431102032,100400120013011,102211241120212,110120032013303,102101230310000,102323011101210,114420000000420], + 1101303000341000: [110124010031144,100021100013401,110311312000001,110010320023302,114130202311020,110002042130032,110244000000020,100003021032001,421432000003000,102210221121044], + 1004102042113300: [111100214100402,110021130004103,114041302322043,103204324031320,112430002022342,114220212340004,100241004324000,111102310012110,103200011404234,103140244030030], + 112004341000001: [102300324010203,102100142002204,110113004402201,100001134100120,114023214101310,110301232000100,110102400013020,114110340004414,110303401230040,110011200020114], + 133011200040220: [100002400100121,114022444101022,100004440012400,100001000413102,114100044004101,120222000002200,110001002130011,102202014020040,110001344200402,142402303420001], + 1010411020110302: [100041200010000,110111001300044,111000002202324,104132100011024,111211010001300,100113434301241,111014014401303,103210001422303,100100000022131,112042111120340], + 1120204111221101: [111420012101422,110444144241024,114120030020202,110201002010420,102001101130120,101004020342000,100230410112111,114224012330022,1000310103100002,101240010310200], + 104003013104100: [114002104014300,102000311102212,100130320031042,102010004040000,112433112020200,112301312020123,112023032000020,102000201101332,102231041120104,100111304300020], + 103010421110403: [100231401213132,114210104113314,114021232300112,103001000120444,101144024000232,101302121004422,100000010011430,100114420000140,102022300241201,110200100001242], + 110223002344104: [110400010031401,114112002313010,114022200031221,110100022040022,102100401410022,104440000012304,130430101032200,111024240404104,101001004012010,100113120033040], + 1100103312223300: [102222320200001,102024101321401,101100021101232,100000321040000,101010001000432,100134101022112,102402004041120,103310200110020,100020031030323,103101200100001], + 1122320140101221: [100203344301100,101000110300300,103420104020200,110131411300312,110200124240014,103100000124010,110030414202400,110032040000332,100011011200212,114200024101400], + 132213141012022: [111113202211020,102000100202041,101021041001434,111200024131220,112004030241132,111203034440323,100232004221200,100201000011432,101042144010200,100112401020300], + 1230000101040111: [102440001113120,114311204002010,110004221040341,103200204031212,102313114114000,114004102201202,100000101001431,101010014001032,100222014121024,102340140222011], + 1003024441100101: [101220111020012,100004024202000,114200020003000,102112430210103,103000114012224,100033131043244,103000024040413,111102002220124,114423100000411,100014201030221], + 124002102002000: [110041030411301,110001041213031,103301210142043,101110044200100,102411000200000,110414300030001,100030020011022,100400014321101,114100122342002,111202012222402], + 131043001013100: [103301210142043,101110044200100,102411000200000,110414300030001,100400014321101,112012020230301,100010101020023,102000221442214,103142111441040,102140101343110], + 1140102323000314: [110200002101020,114104032211214,102410400233132,103101011210300,114213002320124,102200200240031,110011212030112,102101114021130,102012410213213,102002010240020], + 1042032223340200: [110340014422102,101022400300001,102140004000100,103202130122102,100021000010213,100004101033223,100231004220242,112430010114123,130020100202200,120002101133400], + 1104300420300020: [110301012022220,100000130410014,102303414113320,103401344004004,110010114200400,102201001122034,100132431021202,103122110400104,101001211002201,102100234001041], + 1010123300040300: [103222100212012,114010112201001,101224244040310,111323210000204,102001030240003,121102200401021,101001324214240,102301010242231,121244120211020,121100000400034], + 132041000031014: [110401004221204,111112000011222,100322444314002,101003301020022,100001030100030,112012004004000,112044204000441,103141100104002,110341300400201,100000104210240], + 201022320130011: [110433012110300,110440201342022,112101414041022,112243340202002,111103412240000,101000204003420,110101240024120,110300310011030,100230101001020,112021300220021], + 101114041010101: [110102042010220,101020124000413,111210000001101,114013400011030,101201104040034,102202000201220,101020111030400,103004104010210,101220024041000,102010300201414], + 122430010030030: [110403302023130,110001004204310,100010311020030,100020000200000,100141230020203,101031121003021,100200120030203,103111201443022,110101214400030,114104040220130], + 200110400021200: [100300041001121,101240004011021,101011001103200,101002244012322,102302210210322,100012401020212,100003131040012,103004044010300,111210004101111,114004130020232], + 130021140213331: [114402404141241,110212022133311,101041210311410,110022004211030,102104101122100,112230240412241,110000204203220,100034141030202,101000300312123,102204141300100], + 1410110013004410: [102102000233342,103302220110131,110100111121002], + 121212010020410: [110330400010040,111000100012002,110022140120012,111102010012102,111300030012334,100143040411011,102404404004104,114002202302000,100034000000002,100400100031022], + 200013001002114: [110442104221030,101224001202324,111211144101202,100002001024100,102103130221330,110000300140010,103102134001111,102011310202304,100003114100011,100002314204210], + 312124010300220: [104100012102004,110030002000422,102102011413000,100402431012022,102403404004110,102031024013013,110044020020202,102122410220401,110021232000021,100001140000010], + 1000212113420430: [102002040220110,102141220210212,111202024134001,100000014100202,111302120011012,101012104001020,100002314210021,103101031440430,102022001101234,111422202210212], + 120221011100303: [102001404012100,1010400230221020,102302200210010,102340120222440,114223204100010,111041202200140,111300400002313,111101040014040,100023014313010,114021040010311], + 101004101220212: [102023104002000,111114010020011,100001204302200,100310111001140,100000004204201,114002104011010,110001221101201,102000031442000,102400014020400,110301011230230], + 1011110400240232: [114020000030002,114031000022030,100201211003004,102014002000401,103103241421322,110110200001000,114121012340044,102000400240203,102104304023201,103310300140324], + 1102202110002002: [101222101202341,100020220410142,110000412003001,120202201010210,112042024000020,110022100044100,114400200004310,110003000024101,100010024302100,100000011020412], + 131110002301301: [102224101113104,114202144102100,103000214012040,100034140011211,102333204110024,102103002002000,102402001403121,114114300221122,100044334102300,112332301100223], + 1034021200100143: [110300221220031,110201220000032,100021214313034,114300200000110,102000021133001,102301434110030,122011001202102,102100301400242,202023004201110,101001021001033], + 1100003040100031: [101030000320122,100310301000321,102001002000000,102300010221100,110020004413300,100121320401222,110021200040000,100301124210103,112211024013040,100040014310010], + 1124201010140100: [100111011011011,100030040101021,114310102300021,114014112300100,114030034013101,102400124020001,100102224234101,101013004001421,103000014011004,102010321411140], + 1022210110130021: [1300422220310121,100422321032021,120032010212320,411001103222300,411311131413022,1220101103414143,320440200013001,410000244003240], + 1120110020011410: [100304201000221,100112021020320,114212104110100,103010001422020,102300124023122,114221004100020,102304100210334,100403210010142,100301104104210,111022134112141], + 113022000112320: [102300000221114,114301000002344,114212310002312,102104014001023,110200442120120,102020031123000,100022101040044,100024000102402,110043301220422,110022400021000], + 1100100020220202: [100102204300424,110102221014102,102002010224011,114000030042240,100200020320224,100011010022200,101403144040010,104133020011042,110031132130311,102022001440012], + 200311014111000: [110301120404342,102113304130002,103124420221210,114032024012040,110100000100220,112000210210301,102012124012120,103431021204400,100031341030021,101014004001312], + 1010300002120034: [111102420023101,102102244000330,102140140210323,102001004012322,100004001041301,210202011010122,110420104220202,102320420240300,102222131120032,100203101000022], + 1211000020003020: [110230000000002,110220301202400,101003140322000,110401001002400,102002001130001,103012000100400,114201142324042,102213401111223,100040120000031,100040030122003], + 104130311211041: [100002100100210,102420424042020,100010001032223,103020031403100,102200401111200,102000430221040,114003104031111,100100000422320,100102020411200,102100012002000], + 1101112101300324: [102000001132113,100042001020203,102002320220202,100120010421220,100000201041300,114011200003102,101020104000040,102432101112141,114412142320040,102100044000000], + 213143030122200: [100032041021210,110004301222000,102040011121100,114310000001232,111202012222402,111322234130000,102040041320010,103203401400132,110104002010100,102042204000300], + 120024032114020: [100102004300104,101020004011302,114212100023341,102300021103201,102410101112322,102121041340000,110010140011021,100123014103104,100001011120400,120131201313314], + 303013014000413: [100022041030000,110100104403201,102202000200010,102214204040420,100010430202422,112340020203003,102443011400041,100010430022021,100002021031032,100403022201202], + 1020203111100020: [100131424302300,101212040011001,110201344402000,111011242233002,102320001000230,111110223004100,110020212130021,101422404040210,111040224110141,100120041224204], + 222010011014131: [111001440020003,110200020010003,114121000002140,100002214100100,102120104003011,102100144001112,102000041441002,102120402000014,102000200210032,100041000100422], + 1430130300002324: [102100201440001,110400011311001,103300120141130,110040002132020,111144202220301,100000000120200,102304011004310,103101410212231,102120044002231,100002404210001], + 322400301320302: [111321220003002,100332104310222,100003201212143,112000014000303,110120200000111,102000010204312,103220434021030,110211200101114,102122001402410,110430001110403], + 1020312101344012: [102011114002011,102042100242012,102144201402040,100014201021012,110000214214420,114021212301131,112010112000311,110030441223002,110440002111230,103002044010020], + 1122122000102011: [102202010240210,102203101120000,100010204102001,100002010102040,112104000200322,102140201401023,100414000433302,114120000000300,103032224000200,102103200210010], + 202213212001411: [114001024011334,102312144114200,120012102310332,101022220320012,103023404040213,114211000210320,112103000204401,103100004001120,101201114041014,102101034001100], + 320214120004400: [110204034240010,104102030012121,110000011100204,102420001110401,101021111000022,102100111413012,101422021012014,103442014000100,103132014002131,122120120140231], + 1040010003012010: [100220034322312,100203104322011,100430020001120,112002224004011,111102002240013,102110000210014,111101142110100,102000411410342,102310314114031,130200211400203], + 1121100230120400: [101222101202341,110301442021010,110001332103022,100010024302100,112041000220020,102022400210202,111304202202230,111300000001323,110000002001040,110101000121214], + 1000110011013122: [100002104204000], + 1022200103210210: [110010020020011,100000001221100,110240242120033,103141100120000,101200400303000,112400002013000,100120440000022,100010314313000,114310424030011,101001134014021], + 103001300220211: [110111001300044,111000002202324,111211010001300,114030020020301,111014014401303,103210001422303,100100000022131,112042111120340,100101141042243,100101100022012], + 100122244200330: [102130020200000,101104020300301,102004204001111,102101004000011,100002040102100,110023330004130,100001104303411,100224204323201,110201124211431,103004240101010], + 1200204124402002: [111302020010000,101300221003002,100000121020303,102403004020102,110200220010220,101000001001114,110020004203240,103303021404201,100020010420242,100100204232000], + 142002102104021: [101000411030013,103012004020122,101322310313010,100000000410101,114403020000214,100003341020020,114110104121414,101313000312100,100040424212200,114040414102120], + 102411011130240: [100011010414200,110430000400002,111121102240240,111320022200100,114000100020002,114104332310202,114410102310421,103131121421321,102101331342000,102010321131241], + 202304002020040: [100000220100001,100122230031414,210303212040010,100000014200104,114011120024030,100101121010100,103002011240201,102440024021100,103231014021201,110110420034120], + 102204104000000: [114201204111222,100104001041200,103300004021200,102004204041000,114210400000112,103230134011412,100012004101221,114122112202230,102301101004100,110432112111103], + 310404203100341: [102011201101012,102300304110030,114412000003141,114120430002002,103020041420212,100112011040011,114033300041020,101201220300012,100401024300321,100102030423010], + 1122001024210202: [114010330030011,103021220104200,101010020320000,112000210211020,100010324210003,101000000343443,110002400011111,100402132200000,111100300024000,103144040104204], + 221134213203000: [100121230031032,112000431120410,103042024040104,102304104110001,101342300314204,114013124030022,100013200100011,114104200220022,100021221021201,110001244204302], + 320031312101204: [100020001044100,1340120100441224,1301223001003430,102330042000001,232020104433104], + 102241201232300: [101413321300222,110304111230123,100031004101000,102003011120001,104101420011121,114200224001003,110010141221420,102201201002010,114310224030143,111214003022100], + 1043331100042020: [100021204100204,110211020000002,111230214102412,100113410410320,111201442222420,114012000022010,114222440003300,111022120023311,110041341300041,100031144310241], + 1000404012003420: [102301000220000,100024114340002,110101231300241,110000140132110,102402010221231,100304100140104,100213444314000,104132100010310,100241000440432,110411200400010], + 212123200410100: [110002320424340,102031100200300,114102134122020,103010034004303,102023032000000,103000204003200,112300020200242,100021044343014,110001002002424,111100404100043], + 140000222031301: [110301042101400,112423414042122,100400320020104,110001404210000,102012201100202,100220021000001,102011210242012,100114330414120,102121314001202,101010001030001], + 111112010310012: [111333104124202,101000304014100,100040011023101,101123232010002,114421242204443,110100222001100,103102000121300,110010331230210,102030020224102,102430014020010], + 1012000440233031: [110041240000013,110131122012210,101021000341001,114010200040441,110032014420232,100012044101230,111304022202211,111021212200430,112010034020230,102100010222101], + 1100112304402303: [102001000212142,114121000002140,110024042103114,110123042010000,100041000100422,114020002303212,102223231121242,102103132002023,100024121030022,100000020001022], + 300100043121010: [103130314001202,102143314000241,100244210034300,114001102211300,101100322120020,103302320110042,110112324202034,110031422000002,100020321212233,114042324104012], + 122431102040020: [102021001132040,110201201211024,110402420402001,110021021210300,110404000000012,102000101120123,110221022101104,110023100402320,100020311220412,110123004401121], + 202011242024002: [103114204002100,114230004110101,102122101023020,100001101033010,102142002000030,102023110221011,100100114302030,100100014302013,102020121130000,101204031024110], + 200012020220101: [110202012100020,110013202003320,101031241000010,102120231343224,111342020011220,110030332100203,100314114322101,114404232310120,103100034001310,114002202210331], + 1414410110001200: [101230114202200,100400000020230,114300124030100,102211020204231,112011204004112,100202031002101,111000004401312,101000034212001,100121114230123,102321014111202], + 1114201310030110: [110132010032031,100200044102003,102210430233001,100110231000142,102420210200041,101003204003100,101312004211100,110010030101400,111022114120310,114003422242201], + 1101002041041001: [102402434020211,114103002311110,101004344002124,114020024120011,100001001032400,102402030203003,103022011400040,102011011133120,101011411002311,114220102331110], + 221241002003004: [102014130241422,110001002203134,111001002201122,103232040100100,110212020100040], + 221000241023300: [111201000013222,114004104012300,100021014100123,101203211010000,101200314040213,112032020220030,102320120240012,100003021030220,103101324001100,102123021022412], + 110004430041000: [111132230010402,110000400023242,114000004102010,100110014032131,110113041303100,110100314401022,111301102204130,103010104011202,101020220310112,110000421320024], + 114103210330002: [102440104021410,102012214041011,110411344210012,102010214000220,100100014322200,101042134014101,111141022224102,103004030120101,112221404014110,101032011143223], + 1000004213102000: [110443000000102,102430100200123,100040214102300,100002214202010,101424010303040,114042244102400,100034400410112,111020012203011,100100111043114,100000044241022], + 143210020000210: [101210331023020,102021111412201,101201000011000,102322124114210,101011211002010,104110411304420,101401221011342,103200004024040,114220000002123,100010214302012], + 1010222200110100: [110323344422123,110011010021004,111220002202002,110112001343021,100002101020204,114212000211041,100431204320300,110001040020213,110112121200203,110300200013040], + 201113000120214: [103211200100400,102112231020231,100022004300020,102320000240102,100042144200000,102030304001101,100020420121003,103020004011414,112002104003412,114201204111002], + 1011213312000014: [111200212223002,114141044000340,114020444100202,114020232302203,102320014112013,114402000003130,101004001001201,101001000321032,100023100104410,100024000010031], + 200200022302040: [110140201222000,114112232313023,100102001000010,112032200230231,112312420202020,114130004004200,103000031240330,101020304002132,112220004010404,112102400202324], + 141201040004004: [100034304101213,114002014100310,112023140212112,112313301100030,102101031412121,100020020121132,102102010220401,100001020100030,100021120201020,111000024404021], + 220320200002034: [102100010233022,114313022302101,103001324000110,100002014200021,102300401001010,103212320212011,114000030014400,111120034400000], + 102201300004002: [144131233204044,120130001004000,101001131032132,110102030010210,102220211120002,114014010033321,101400104042212,1003022312322100,102001244001224,103441112000230], + 1403121024040210: [101020024212042,100041204212120,100410110420202,112423424042102,100320431000002,411200101402221,100120214230002,103204200103440,100210004104001,101410201111300], + 220300201301120: [100022041001002,111240340004003,111101222244030,114032424122040,112011012004300,101021401003220,100301020420101,102002202000000,100022024100041,102010410213111], + 122303001300104: [114211440211420,102200024042003,114320004030033,100231411001200,111010000022022,102112200321043,101000021140240,100001011040221,110221102221300,101021311001001], + 111203120100014: [102044104002014,102022000220004,110210001310230,103001220104301,100010144303000,100102434300310,100421200001003,114024200040223,100133404030004,102240001100210], + 220020202243103: [114003010024040,123102202010320,101020211140102,102104120200134,100120230012241,104210140212241,101112240323103,110203232020010,110043200023212,103441014002310], + 130230234000404: [140420100400012,111001202231001,122012440110401,202220202402001], + 1124221120201422: [100040201012040,114100222310230,114131002342130,110002022003101,110224130002014,100403122201202,100100220403100,102303304020122,100310210142030,114132012200110], + 131344111020111: [100001024201214,103433121201311,103404001214121,110113211301114,122004120000100,102300002103012,113030410122021,111400202101243,101012114000111,101020211140102], + 1040302200342312: [402000401204030,114124020222032,102121221343020,100140201000222,110110000004210,101400010303002,104200202141001,112104424022201,130030220200012,112200110000221], + 200002300140211: [101021014002020,112000404000001,110320332022210,102230040200111,111241000001011,100240034101400,100220304100400,102102004000001,111000412203041,102400121110000], + 134200201020210: [114021412213020,110030002000422,100032121024110,100402431012022,110040002034100,102031024013013,102402330230011,110044020020202,102022400211311,102324410243220], + 112120200100343: [110130102010010,110100030123401,110001010030000,110102202013213,110021404214210,100003110022310,100000400100142,114102000003021,102220314013103,102002034001310], + 1000144202110034: [103033004011100,111320122204241,110132212010200,101000024000022,100000204310440,110110100033221,110000224410201,110100400020121,110011304200020,102030021102211], + 1004033332023033: [103214010102022,100043324210140,102324014112020,100023024211011,102404021403141,100010004313001,100003201021001,100122020011232,100002200410030,100121031014040], + 130220204001330: [101400004021110,100000241120103,114232000002310,100402000000101,101000114003100,102202301300240,110010044203000,111010014400030,112211030204411,110210102120000], + 210002202200000: [103211144033404,102123040212103,100041301021020,102314224010213,112113012010000,100000120000202,111000030043110,100002314203420,102001121134000,114220414000310], + 101220020001403: [102342014111202,114040002330341,411010033020221,114102020422002,1224320120024001,200002003223300,1000412032200202,300204110434340,111100001002113,132220124203004], + 102120012021134: [110400000002213,114132100210100], + 114000223000041: [100011200121231,100102004100201,114040020021023,111230114102201,101400300300111,101220200301400,100001101021134,102122302000300,100000300202000,101022031034002], + 101110430324122: [110200002031302,101403220331230,102040021121030,100000204130001,100412441010422,101010200312020,101040204210210,100000201034001,110000324412304,110000201230100], + 102113104000201: [102041310200042,110320202023400,111431110000042,110301030010140,114101420030202,114421242204443,110104422010121,110100222001100,110302204433321,101010001002000], + 1000302330420004: [100000020004101,110130014400011,110011232100412,100220040142222,110232002101410,110200021210212,110131021240303,103100101442233,100424331001120,100000031220100], + 300220113110120: [114021000012310,101042410301221,110432300102000,100011004102400,102304000210204,110040344210011,100020120101000,100003200020112,100400231000200,101000100340001], + 1004301013110120: [103310020140014,112000204002100,110210030100111,100041200002402,100000000411240,102030021443010,112300220202122,114010000024012,103100421422110,112120002302004], + 212044320041421: [100244104101010,100200011002201,100211310140340,100200024104410,100220011004202,100000101232030,102101200200034,102243201302244,104430421104102,104100402102320], + 1030202410202120: [102222111120010,103200224033413,102300440221022,104120201242031,102320110240231,100100101011200,100133001220421,100122204301312,101022220322100,100114113200203], + 110020300043342: [102112020222030,110320022101120,100022431030100,100022004301043,102214101120310,114000040031021,102400001110113,102002224011000,101030204214013,100004201211032], + 120220023043020: [110024404211001,110100022010010,100120001040202,102140140210112,100004220412010,101222020304402,101201130302002,111020400044101,411120024124200,114202102321131], + 130300014233341: [100102211021000,114203142321301,103141011240230], + 1113010112422040: [101012131000024,102120221022200,102110141410402,101044001032114,114221104114000,100001111032112], + 110020210041024: [100020400410010,102103441142340,101211210304010,102100001004041,110000403400000,100000414104102,100001020044101,410310420012412,101000020100020,403002310120143], + 1003113220430003: [102422114040010,102020004001311,100101101010100,114103212312012,102321044112101,100022024100041,114231212342200,100020011043020,100021231020200,114201112322020], + 1101000402201400: [102000004002101,110202000000310,100422314300200,101403014020203,102141410230020,100042030120422,101134224001001,110020001224021,112100000200031,110003032000041], + 101002121200031: [101203231002222,111430032210010,100000204100040,101003030304240,112113224020012,103002211240301,100220120432010,100004014202422,110411232110220,110220042121003], + 1141011011423232: [100012014341003,101100411104001,112111010201220,112222122032004,110100134403210,102300210242404,114300432300422,114101144001040,100040414212104,100000424304010], + 1410200232000002: [102422114040010,100022041001002,101204400304011,114032424122040,102020004001311,100101101010100,100301020420101,114103212312012,102321044112101,102002202000000], + 1042200002202040: [111223402220443,110430000400002,114033000032021,102401004043011,111320022200100,100300001002041,103000200122014,102203001120342,103133004002010,101202330304024], + 213021140040011: [102230040200031,102101204000010,114230230000123,104121001242101,102024400223212,110040004411003,110211110001322,100014110201012,102200310201220,110300014422013], + 1003112022201200: [111000022202402,100430211011410,110010340040012,110014032101430,104421312102244,114131014101010,102240214041033,114200322333401,103010021422042,100000001022401], + 1001031040033013: [110023401320200,102301224110000,110000312001020,102133211401043,102010214000003,114032204104044,103002010100104,100220310430010,102124011340031,102410110232000], + 1020014220203011: [100012320001320,102000331120104,114040300043111,110203111111000,114010030024204,102010201012014,102041204000002,102323204112320,100402201004014,100420404320101], + 130003010203330: [102211220201114,103000021411202,102101004030220,102003001132213,102100204030012,111432000004311], + 220210100042200: [102102430310202,101020030332430,101022004214304,100020101031131,101010000323030,101001414212120,103310220113140,114200202330330,103101101440200,100000101031020], + 1003010414041111: [111200200000232,111410210001002,100101001011114,101430004040203,103122104002013,101020404210020,114040414014202,100000024301031,112022140234004,100143440001301], + 312040323040010: [101211104040023,103042004001000,114233024034201,114030002301220,100221100432104,112003120220142,114010430040320,114303222301000,110001022011241,113423202410240], + 1400412203240330: [101020341034234,102113101342000,100212304243333,100431001010310,110002010042440,102022401412124,100121210402002,102212004030221,100030404311202,101410010330014], + 1024110200120012: [111300232202103,102301401002404,110122120100022,102012004010000,102400100220000,102001104012021,100242444300104,102002104014323,100401241010122,100010010102122], + 1040202023020134: [100000020004101,110130014400011,110232002101410,110200021210212,110131021240303,103100101442233,100000031220100,111010000021300,114200444140203,100000124211001], + 1100220301211442: [101240210310204,100000021023020,100100220423210,100231020112302,102000111441024,101110204004210,114240000000041,110004010004010,102210220202001,100110040020104], + 1222211202201004: [103111004004410,114220012340000,110102141201112,103112024030310,112210222040000,111100002220221,114011014010300,100000020413022,102244101111124,104103031240201], + 1201104001013221: [102000324040000,110222200103041,112411400202001,110212311111030,110000110022002,140143400110002,102042211100202,102010000200240,114000002302204,112431244044400], + 221100201100100: [112030004004130,101340041000104,104100212101403,112001102000201,110404212112030,110104220400022,100040020000313,110211130002000,110134310404210,101420000330441], + 1114122030000002: [110104112010103,111102004100101,102202414041044,102000104012232,102021100220101,114443330001442,100230120001003,112042110220004,112203221102231,114022400020320], + 100142421420401: [102002212000021,102013201320403,101134004004013,112230122032000,114300300000020,100020001040312,102203011002032,101000324011134,114302022300311,102220301302413], + 212100201001020: [100200101000000,103110431441100,100011004340114,100011200121231,111201102224324,100102004100201,114040020021023,111230114102201,114201102342110,101400300300111], + 1400100010000112: [110230400000202,102012314004200,102112304002110,100432014100103,100104220412020], + 102430101140002: [102310000222133,114104310000002,102100011413420,100001001034141,112123102010143,102130201140012,100010204202202,101101404003003,112422320200210,112100211100021], + 1102202210214234: [102104101340301,101033011001100,110014010012200,100100004230402,102110304020201,110202420004101,100021220010031,100000014211030,100000200100141,111303012201100], + 200012204110023: [111011304114002,103000001402120,100020314304002,102120400200003,101020300320020,101220301020130,111012310000204,101222200301130,112340340203340,103203314020144], + 1101000220032204: [100000031211103,114210424101200,100420110312244,101420014021400,112230324002000,112320301100420,110101024402203,112001202000203,111034200010244,101122000320210], + 1002114144412000: [114202012340131,110322034430002,102323131001211,112023102003010,101010104011313,102000002041020,100320021000000,102034100223241,102020014021021,102240234121424], + 132032202211121: [110232022123020,103140044032100,100010240101221,102100010213413,101024011034002,100032224101400,103033044023040,102403101400210,101021410320100,102430010202411], + 1441300113003204: [110000021202100,100420014301410,100010101020403,110302030011010,100101300011010,100020111001344,100022121024103,114401032320120,101201124013202,114223002333020], + 212100103212123: [110120200032000,102140011140002,101211001023004,102204024011121,101012100320111,110311100001210,100214200000020,100000012212010,112122034022100,111230102222200], + 132114221021100: [100002010413410,101433010300204,114310100000110,112002020214003,102010231121200,100140301000432,114400022311400,110010220410220,114040010022000,101133104002112], + 222223344212101: [100000201020000,102030024112031,102401011401222,100002002212000,102114341341012,111420200002021,111001224121320,104042022102100,104030002100140,102104120200021], + 201140431200121: [100114234102203,102030000223410,111101312240400,100231124320130,114000010012243,103040424010400,101141111100022,100000404100021,101332011001000,102103000310202], + 102004443030100: [111302204133040,110300000011120,100000221020004,101213020304210,111020010022310,114011302300101,102420021400002,103221200100302,100432211002022,100424444303100], + 212024120403302: [110240301111040,111123014100000,114200000003241,103103404004112,100110120023012,101042044010040,112021014022022,112002322032030,101040401030013,111300002204430], + 1122013000001010: [103313111402304,102031212011001,100010044312000,110213220000201,101204034200001,101002200021030,100031011012000,102000141010102,110304220100002], + 1140001000214020: [101221020040220,114022412330004,100103104302044,101041030320401,102141212000200,101203121020430,102100104002224,102020004000014,100000211023014,100400001001300], + 1130320404222410: [103111001422000,111244302220204,100042100102211,102110030200120,100202140000111,101114000332010,112112211102024,114001032300011,100142044103021,101100010012423], + 201121430001102: [100030324200410,114202244112111,102110202001010,100031021033010,114011404103142,114200020003431,114041002212302,101002200343110,103332044032320,100212024322044], + 1001220024010440: [102011201101012,102300304110030,114412000003141,103020041420212,100112011040011,100401024300321,100102030423010,102101004022104,101432240300300,101232104042101], + 112220043001024: [101221422120021,103001024002110,100231114320100,100001000002210,100400320033201,110011402100202,101210300302302,110100012120201,102020131413423,110020204200342], + 200402011402220: [110341200403110,101130034000022,100120004230130,102030041134220,110000400142301,114414014142230,100000004302210,111001404111020,100024041230002,102000104044004], + 1003110001234320: [104132340011314,102203304123030,114012040020310,110000212104130,110200200004002,101000040320021,114131040224332,114002210021300,103230114000201,100123020032031], + 1203102204020140: [100000010202003,114234324112000,103200101401010,100002231021012,102400001110102,120413040002400,112410024040000,102300234110002,101221001202021,102111134001302], + 1000430300020111: [102021001132040,110203131211112,102301004110004,110402420402001,110000112100402,110021021210300,110404000000012,102000101120123,110221022101104,110023100402320], + 202100013022332: [111134204102000,110422200000213,101020031000300,110000400000233,112000112030300,110240010002041,110021040001310,102120001120141,101003044001244,100131121222212], + 212101100440000: [100031300002022,110210022120040,110000021221134,103002044002032,100101020402424,102201112000001,112211120202000,114211040011201,100020100423404,110001222202031], + 1040003320021143: [110010000111020,100430014323000,102011041320000,114240012324120,100022010022031,102014140200013,101240110302200,100031204311023,101232001021020,100012121040101], + 1141001103140230: [103000024014022,103010000100410,100040404102010,102203240202202,110002110021301,114231020001120,100100211012004,102340202000001,110020402100200,102023210221301], + 1000030000032103: [100102000022402,100000001033001,100124100031200,101010200321022,103304014010000,103123041444340,102200231120202,103342100110221,101021220300001,113023341020302], + 104023223104010: [100323401000042,110103020011001,110210410123112,101100004000244,101000014211204,101011204004013,114422004142011,110022010002210], + 1002220100110100: [100122420031012,114200334112132,100210204343141,100000104300130,102202401114113,102140201342144,101021001031113,100100124234311,100022004310010,100010114310001], + 132310100001031: [144131233204044,120130001004000,101001131032132,110102030010210,102220211120002,114014010033321,101400104042212,1003022312322100,102001244001224,103441112000230], + 1001303020002020: [110202012100020,102303010241010,111342020011220,100314114322101,102230130203001,102021401324232,111222102243400,101004410311232,101201034010420,111220410010144], + 300211300011104: [102023324010020,114000004103003,111131002212014,102110100233222,102120311402124,103140124002022,101042421021120,114013204013220,102000100221400,114241204001213], + 1041044202311111: [110401004221204,111112000011222,100322444314002,101003301020022,100102431021300,110200212041001,100001030100030,112012004004000,112044204000441,103141100104002], + 1020202240114112: [110200321303322,100010030100011,102012124012120,103002041402004,114120034123300,114010112332112,114204202332300,114121304121000,102221024044110,102030004000400], + 124300110101232: [102000004002101,110202000000310,110000010120043,100422314300200,102403404004110,110301311303102,102141410230020,100042030120422,110020001224021,110103111120042], + 300412012111013: [100040240004024,100010000002400,112000013244041,114020100001120,101002041000124,102100000231232,102030034011211,102000400221230,102122001404300,110441342010200], + 1021041112002002: [114020200020222,114330002323002,114001020042001,102202000240014,103014101432000,100003014100041,102100121342000,112404410204002,111222002224302,102214011120002], + 102334000202111: [100424331001120,111040300024044,111020232200302,103124000104424,102100102002012,110201014241230,102110431342142,114201410004440,100040331221012,114442130003110], + 102211130414013: [110310001202220,111131224100212,112000112001400,112111412011211,101240000302141,103414034000124,100002020110200,112410024043011,100003200400110,101222201020020], + 124001011241420: [101232314010241,100301300121100,110042400130000,103020124010320,100021300101201,110230022122031,104101201240100,110000011012202,112102112301130,101244324043222], + 104220142130201: [100040201012040,112021004003303,114100222310230,100011120000004,114131002342130,110002022003101,110224130002014,100403122201202,102303304020122,100310210142030], + 1000013140040000: [102311004012010,101020401033332,100012001023022,101104414002010,102112012004120,111112242211204,110422020000111,100004020021344,100100000000042,100000041201200], + 1041120100004010: [102224420201000,103013034012221,110302311302101,100000120002200], + 134202314303143: [110102401201204,103020200141000,102400100230000,102414034040100,100212030414010,101200020303202,102020041321410,111340300010010,114120420223002,102013224003020], + 1001420010000230: [1020102021344321,101030301001232,100104302001300,1001102321230101,1002001200441033,220200021120010,100021204230002,1401214001003110,1023121121030343], + 132200000042020: [101211214040304,110412001213211,102040234002003,100100021013214,110420202110040,101301204220200,102304422004020,100000110400321,114011120033402,110020330014410], + 103032204302020: [103110044003033,100123041001320,110310010113001,114414120002440,100221101003010,100300314101444,101130430331440,100002120004202,102200002021022,112123104020101], + 1131304130122001: [103010231401402,101011400302300,112003012002211,112002414002043,112442004040022,114140222200101,111104232241021,110013232131112,113022341002031,100013411042212], + 1114320030021030: [110202004211120,110223224433004,110341010044330,102031144010424,100302420120212,111212114131222,102140001441301,102223400201104,102342120222031,102221010201113], + 121002010411143: [103102300102243,102113020210120,111202004100121,100020004310022,100222220001202,100003100122232,102000414010131,110410300402321,110020014410200,110320100400100], + 1040211400101414: [110233012120121,100000241030333,100020011020010,101000204002210,102000131130020,110112210000002,100001204130442,102100321410122,114024004020023,1014400221004004], + 210200000101402: [100422211004214,102100000210002,102121010210004,114013214010111,100010004210020,112002100240200,100001404100110,100002044200330,101213110310042,101424044043122], + 1400413220404104: [100003030003020,110410000104042,100000040413000,100001034310012,121310232003222,110011300143002,100220021000033,112011312002001,102110201023020,101344331000033], + 100003101320110: [100010104331200,110342022000001,101000204210021,110100121224222,110002142120000,102011011321024,112311212021024,110100100030303,100043100103044,110302030004323], + 124100012022014: [101032111230411,103010110120020,110100032122000,101020210301131,103201004020101,110200001314040], + 103140020100202: [100023421041402,103101224000011,101144134001102,102200042000104,103002000104400,110114021000012,103002144042123,110012220002021,102304204110040,112020004002110], + 100021323044101: [110400000002213,101101230331040], + 102330100031011: [110120102041110,114002242304240,102100111341030,110213131203122,101203440304221,112114004043430,100002334340000,110010432000001,102111044004101,100121101023404], + 123000400311001: [101002204212400,114041204104222,102112300201410,100100121043010,100323120143000,110432111241204,114200200002223,112123142010120,101002321032002,101121100013002], + 221041130130032: [111120002211010,101201200310001,102023120241131,102020000201200,114241000002004,111232000010230,100424200020200,101020320323422,114220200214400,102010001104000], + 1100202311010001: [101010001000031,100021020104221,111120024101141,103201214021013,110310304430141,102113304130002,102000131131100,103124420221210,110201002043201,100011034302423], + 103000100303220: [110111222040014,110100000123402,103003024001001,102004204000422,103010000120000,114211324100034,102440234021012,100240011000000,100002030413101,103000310141142], + 1403120024024100: [103123004002102,101020000320220,110111140011114,114131304142010,110132011002023,101100020300101,114423210001210,101040024002000,114020024010020,102040111124412], + 1200302124321320: [101230002122040,101210241204043,104102040011120,111311120014011,100123011004113,100420001002101,102430121110340,102020121102120,112141104020201,102000024000002], + 241120112010000: [102000001132113,102202310203222,100042001020203,102002320220202,100010044300003,114130210231020,111321314133000,100004410120102,111222214101043,102100044000000], + 1041302012300000: [100002014200331,102012004000003,100411000030110,102041201121230,101000210303342,103000121424330,101012204221200,100300114310112,100202004324322,100143244100101], + 1040120000222002: [100024234201100,100010234114300,100010044310002,100331200141014,130000420243230,100232104120201,110112204224100,102212234021233,110224102230230,100120411200320], + 1003040010110001: [100032401030200,100021420120102,100014014210044,100022214101010,112434200202302,100310410140021,102001000221230,103221100211210,112400040102210,111110244102101], + 1003020101210132: [114444244144110,114201004110120,114033234032101,100412114304000,103001020120202,101004411032102,101000020302400,102021014012210,102244221114031,112400000200011], + 1140002103000201: [102001130220001,101410211021400,100004214100234,103000011400001,102104241412223,102002421442002,111131214422402,103100000210002,100000004200324,100013001031000], + 130122010311204: [102030111100022,102120000310301,100200040430313,100010021220004,112040021112102,100010000000131,101034124001203,100000311031000,100220124220140,100011101020000], + 321330000144224: [101000004210011,111230342220010,114010024011000,102000101410201,100004111024200,103302100140200,121103000144034,100211044311141,100111104002300,103002011432010], + 120221230002203: [111222202220021,111432124443120,103423201200020,110332111334020,111042000000020,110000001012000], + 132002410000033: [110243234240200,101301014221122,114110200212210,102041220200010,102130000312121,100400122201222,110231210001113,110012130410040,103210034021301,100104101200201], + 101101010210344: [110201201211024,110202000000310,110000010120043,100422314300200,102403404004110,102141410230020,110020001224021,101110020013040,101012410301010,112100000200031], + 202300121000400: [110320414420310,110100100101041,100420124100211,103010211222002,101040120320230,110013021300010,101043234000412,101220000040002,100422001002123,114010010010002], + 222100300214200: [110223010013204,102230400202000,100000121040140,102241330244410,100330041000221,100342011001201,114102100034220,100044000103202,102023020203230,114110200004041], + 1100013000421002: [103100030100010,102013110201200,100042000102010,112000230220102,102013000202010,100200001210240,112010022302321,101040224003400,102304111101041,103204101402321], + 103000012020402: [100404000022030,102301121100200,111131004101000,102010300200001,113003022402221,114400242311000,102201102021043], + 1000201230301400: [100021104340400,100003000410404,100230404343341,102002301442023,114200322333401,102403001400101,112000134002211,100000001020020,101221022120042,102034200222010], + 1023410200200310: [100040300102020,100012230204000,110131214220303,110143101120300,101101200311102,112401402023020,103142104001331,100200204123011,100301400040120,103031120143010], + 1102103311313110: [100000201020000,102030024112031,102401011401222,100002002212000,102114341341012,111420200002021,103421124042304,104000102100004,104021021224211,100100134300302], + 120200232204041: [111441300003100,111211414134201,114200044000012,100140101203122,101000121143120,100411310430002,112401102010230,111003000021043,101020030300010,102242011301200], + 133101010301002: [110101231202300,102023324010020,100130444102110,114000004103003,100001204342232,111131002212014,103010304012101,102210044010110,112000404000001,112000001121002], + 1002032043002014: [100004101032202,112100002011214,114401022311200,114020004020300,110114130114210,100004321021120,102300420220003,101400211012100,110012112003243,102104000213123], + 210300102002144: [104244002023000,120133001040211,112200431102021,111320124130040,110000110000231,100142041012023,110000000411120,110302100010342,101301030313022,111440222100012], + 1000100104404124: [112213000200301,100003224334120,100404224300012,110204130004030,110202120003032,100322004314021,102022010220223,100404000020012,102343301100440,102410434000220], + 1042412021024000: [101240220300022,103011431401300,100022000410041,102040300241403,103020000102011,100013011020311,114021004100210,103000310100320,102103331400000,101040421033204], + 1421000230400442: [102200004120034,101000024002230,111001200003214,102100021410210,110012020021204,101001420312100,100022201044101,102200010204000,100031000413030,100130241010201], + 1404022130033110: [114032104100141,101213114040141,102210101002412,111140100011101,110122421241103,112001144002010,101013030304101,100012011022000,102000004000013,100002021033103], + 1210000442011122: [100000044240301,101140021101302,111120224100101,114440120000030,101023041001203,100211400140102,101010040320111,103023101420104,114300014030021,114000010041302], + 1040120310344430: [100004214303020,131001224202110,100100400113040,131100001014001,102211122121042,114020420021403,111000014110301,110000012130411,102213244002203,114340224031221], + 1001130310002130: [102001404012100,102340120222440,102122214131011,114223204100010,111041202200140,100023031000024,111300400002313,100023014313010,114021040010311,100020004101012], + 1020001131220331: [100020331001310,100402010022123,110200131102200,100430204220020,104110241240001,110011242202000,102201012022300,110000421302031,112131442302432,103202111411203], + 1040212410000200: [101033101002303,102001104010010,112002030210041,110002102003311,100041130040040,111000030042302,111013004412334,110402410002301,110023032002000,101201010301001], + 1111013232224020: [103011041410132,100102134031030,110233000100021,100112104301200,100021242211014,101001210201440,101110040002210,110211104432213,111401304441341], + 1000010210231030: [103114204002100,100112011040011,100401024300321,114230004110101,102101004022104,101232104042101,100001101033010,100000201022420,103000011403101,100100014302013], + 1100010300003000: [111121100010021,110310034424102,102101211410144,100024201030210,102010111102410,101000110322242,110100001014311,102404110230202,110043400012000,100010020101222], + 304410010232404: [100114004100001,114102300004024,112102201102030,103222244003021,102420011111224,100340114211043,110232020002221,100033001220020,101100120334014,114233002340141], + 1020040001002013: [100214104301120,101002000321201,114300014030310,100130004300103,100040004331010,102320234112041,112420030202242,101001424004240,112321101102000,101401201013110], + 1102020022034142: [110400010001201,112012002002332,110412010002312,101004414000144,100143221000221,102000214001143,100312104100320,101002224000124,101022110304020,100104104002111], + 240012020420010: [110013030403023,103010204010010,112003002030002,110401231001202,101031211140304,114230110212040,100000034301140,102111011142022,114132142312022,111210404410344], + 140132113010222: [110330400010040,100101231004020,110010100022010,111000100012002,110022140120012,100143040411011,102404404004104,114002202302000,100034000000002,100400100031022], + 100301020102120: [110202102121414,100110014103210,100041204331000,114012032240012,102130004002131,110143020121321,101413001100003,110130020003201,102414231403301,101402211011032], + 1031020022320001: [102021001132040,110200400000020,100032201024101,110203131211112,102301004110004,110402420402001,110000112100402,100002204340200,111140000000000,110020041310021], + 1102000101201030: [103124001420200,100220210034042,102401001110000,112011300223041,102002001133122,100204011000221,100040020103014,100000201032240,102031010200002,101240204232402], + 1120222011041100: [101321001000010,101010424210144,102203011120021,100130014300042,114034400040402,100010100102032,112010344023013,114002002300222,102104000210330,101401300301000], + 110010000102200: [110102401201204,100222004320102,100110004103122,102200130202201,103020200141000,102414034040100,100212030414010,100000111034100,103132114002002,100412200002013], + 1000202000424040: [112102202040000,110100104404110,102110042001043,114100002204212,102003000212104,102000100220240,102030204000041,102110021341014,100210120430200,110203221112042], + 1023200020002101: [102010011411233,114004322320200,101030114211022,100403220020024,110033124420110,103102100122414,100121034230014,114322002322044,112040200210223,112002142310023], + 1021000100401030: [114000222211300,102130040230200,114030034013200,102303214031001,100001010101032,102212241110430,101124314020402,110130402140002,114432002322240,101402104020302], + 100113200442214: [103310001400000,110042014203200,100033304311022,111001210040344,100122401023041,100131014232113,100221000430010,100400302201222,110204020000322,101104301110011], + 1020310211300232: [110441234224400,103100014031411,110000300424304,100032121024110,110013122130200,114020204102020,103121221400012,102022400211311,110030400004330,102004204001111], + 122011330001240: [103000004012003,112303041103203,102101024022111,102020231440400,102144200210031,114030304122412,102121104130242,114104220000003,100112011040312,101013200321014], + 1044033110002024: [102010244010000,114430412322343,114200034110031,100000430014301,114423002314000,114040002210432,102214020242110,114010134021022,100010040122204,103314044033003], + 1103102304021202: [110000222102001,114400012323303,100100400412043,111000000020420,114320132322101,114320010000123,100021044312310,113200212430221,100010020023102,100000210000040], + 200231242112001: [102202310203222,114404010003320,100042001020203,114130210231020,112114324040000,100004410120102,111222214101043,101011211003002,100000241000002,101001040304214], + 200331011000030: [100100331000022,114222040214020,102000111441024,114240000000041,102032000223300,101013024000102,101000441140230,111300214121201,100100030402001,102400400200100], + 1022000100401212: [110010302000004,110410000104042,100014014203233,111422100034314,100102001013034,100000040413000,102030414003000,101342020314000,121310232003222,141000013100220], + 1001041002002004: [110002302010012,101212001204031,112100232040011,100132034104220,112032410212442,110021233042220,102002200222041,102404414041110,102144044001000,101013211000001], + 221102021000012: [100000430122100,101200100304010,100000001033001,102020200220310,100124100031200,101010200321022,102000231122032,103304014010000,114020002212200,112402002010210], + 1004212300002131: [114000024100022,101022004214304,101001231032003,100043420411130,101001020322010,114112244122013,103310220113140,112144232304210,102443421400110,100043041020120], + 240012400200230: [100140200020242,100004120021240,111201022223123,100131101201030,110001020030002,111421014442003,100100244002230,101010001000241,102000221100240,110120014401401], + 302210220143200: [102123220230210,101110004021320,102201230200104,103012101401220,103001334010240,100214324104012,101333201002122,103200021404423,102003114002001,102013010220212], + 1102200224120041: [114012304010103,101232404040100,100044000201201,103320304021024,102102020203131,100000301041003,114401322310000,101110404001000,100000000101012,100043204100144], + 121014100100044: [100020011041102,103022004000010,112110201100113,100412131010010,100130024000300,101411201111042,112122234040200,114122100211000,101101001110221,102302400213001], + 1013221232224201: [100203321001221,102310400244210,112111040230130,100004101023023,103010041241404,110333010011034,110423301004320,114000300011121,110401321340320,101110140302324], + 1121100201201012: [110202032123210,111122004100020,110412244220110,102411314024401,114001002300430,110101230100001,102200034024120,104102130014402,110314042102142,111120122242010], + 141021101412421: [111302020010000,114213222330042,101300221003002,104100212101311,100000121020303,102403004020102,110200220010220,101000001001114,103303021404201,100020010420242], + 1040412113004002: [100014100100001,102100004130301,111120004100414,102201101122100,101034024000101,103340410140122,100102114100420,111012202111021,100103144302200,101414100300221], + 1123140233130000: [100121230031032,112000431120410,103042024040104,102304104110001,100104211044110,114241222321321,114021002302020,114013124030022,100013200100011,114104200220022], + 110020043303032: [100024000110221,114130014001202,110010220103020,111004100022110,114040210022000,111001344400222,101021204010011,100404410022320,103012101410102,111000000000411], + 220141021000201: [110442104221030,101224001202324,103102134001111,102011310202304,100002301040000,112000132001414,111124402243200,102001331441012,100203014121400,110042002002040], + 121044040131204: [102133011413110,111001200041102,114022424102243,101223020300040,103111420110210,102034324000220,102022400203211,101230020303000,111340130010314,101214240300041], + 223222211002011: [110040102001121,110200321303322,114032024012040,103002041402004,102103030210003,103010011401200,114121134124014,103013224034023,100020014210002,100001421042312], + 1010002004220233: [100004101032202,112100002011214,114401022311200,114020004020300,102420400200000,110114130114210,104200200001200,100004321021120,140243003020120,100003040102022], + 100002100000004: [111030212113431,110001030120020,103222004032000,102233034000002,112130004021000,100100200021431,112101202012010,111212024101031,101013040300032,102112314002011], + 100000201101100: [103012034041202,100100204100022,103130031241103,103234031200401,114011320024214,100233001000010,110322311300120,100204431000210,112100204000103,110022040140021], + 1022102240321112: [103034010121101,102302200210010,102340120222440,114223204100010,111041202200140,111300400002313,100023014313010,114021040010311,114140004123122,100002301021040], + 121312113301020: [112311011101001,100210201001001,101100001101401,110100124402042,111120402212201,100101021021114,102120404134413,100210010430242,101411001011011,110040212000010], + 133122111020100: [110021000410432,100042304102210,100013030100002,101010010320112,112000021122010,100021111043012,110124041140000,100010044101002,100001000100403,100020124100010], + 230330000200020: [114002104014300,102000311102212,102010004040000,112433112020200,102231041120104,114132420004104,114100110220013,101431304024200,103004021430003,100040404202000], + 1420420332402401: [100232214222204,100040324331403,112104212010101,100001104201201,102300221002020,100002101020010,112010202000202,102033024010010,100004001000211,114230112330402], + 130022024022302: [101001400301113,103101024004200,103024000103302,103300021402104,102014111102023,102102024000001,101301014220002,101012044004042,112410300200001,102020304000321], + 220002202343040: [102114340204022,101000011030111,1303043020124234,114403402311003,111143400421100,110221310000130,100223331020012,120313211020000,1013001120112020,1311314200100310], + 1143000013403000: [101020204214020,100131144232400,101001004220021,110232241101002,102104101340430,111333020000020,112233010221200,114020020001014,102201401001104,101003200300401], + 231323022320340: [110202004211120,110223224433004,110341010044330,102031144010424,100302420120212,111212114131222,102140001441301,102223400201104,102342120222031,102221010201113], + 212311220313403: [103300121401234,100122200020013,100004004210020,102331104112002,110121112010004,114132002200241,102330144110211,100404000020300,110214202124100,101200004233120], + 120040001042420: [114343002322014,114100022342130,100013024312024,111012002200101,102102211140013,110020220022010,110210020002243,110121220000022,103400100130300,112400434040004], + 1420010032000210: [110000212101040,110301011234204,110021410020203,111120002100412,103330421400224,112024232302040,114013022304040,101023410321122,102021311100042,111000304400311], + 240402440400100: [110111032140220,100023101042010,102112310210202,102330010243440,114042044100403,114221224002403,100013310123100,100022410101442,114200022343003,100024101022010], + 111100013020240: [101000201031101,131204100021112,113003221014312,103440324001431,123400040222113,103102104003010,132220204100102,131202200011113,102044400022000,112120140231000], + 1004040110002100: [101221121202421,110020102000133,100000204342022,100001020012120,111042022141200,101441101010020,100100241020020,100002004342004,103010330100320,110113042000320], + 1120212202100110: [112342210200100,101021020331240,100020400003003,114100234000201], + 100000000140300: [100002100100210,102420424042020,100010001032223,103020031403100,102200401111200,102000430221040,114003104031111,100100000422320,100102020411200,102100012002000], + 102301020111410: [101022014222024,110100120400020,100032000101014,114000024101202,111311002224001,114030000030012,100032134101100,112010024023002,114231032340010,100000010202201], + 200000200033000: [114343002322014,100022314100104,102130314131401,114100022342130,114300010002100,100013024312024,102002020243020,114002002300201,102040021121030,102102211140013], + 1001304001303142: [100000431020101,100244100032320,110010212101240,104104001243020,100032040000331,104124102100301,110002010440412,110111420033313,100201310000404,103100200103020], + 241003123120040: [100422040021304,102000024011300,100021320123031,100014041042003,100002010413410,101011210300000,101433010300204,102114321401000,100002414201103,101002221140440], + 130210200223122: [102020314012030,101002100323042,114110000002010,102110300210002,100010200101222,114004000020012,101031001032010,114442102310324,102324400243001,100440000030010], + 121021240400431: [101043224001442,110041100141020,101001004002100,110300214430000,110002001220310,111331104131204,101040204002221,112200004001330,102300121100001,110421102110004], + 141422230020000: [102230004030112,100100221012100,1002022012411300,214021333002200,112102000202302,103013200104400,100130401022113,112001421111242,1011001024420302,114112402340003], + 1110103102004001: [103204424022010,110304304420001,102110402001413,102131334020220,114210024001201,1031024222000122,200003020011141,100020111230000,114102010224000,114301012300202], + 200000010033000: [111320012221132,102302144110440,102143202000400,111020002202333,111130224102101,101321311004010,102110241342210,100002320411400,114201000004122,100143034304100], + 1102030130400422: [100000044301222,111012034402110,114221004034110,111100104104202,101223041020020,102002204000124,100011230120014,101104024002242,110133120011001,100400010013033], + 103242023022021: [100013400423030,100033100421220,100032221044041,112210034000434,110131142113202,100030011041024,100011114313403,111010234110022], + 213010221032130: [114410024110002,111200210001023,101101401020424,114030220011120,100002200100100,112410110201010,100020000120134,112422100200404,110202001212002,110001014204010], + 1022203112204104: [102000101130132,100402412200004,112040100210110,111201210000411,102204311100014,110213331312003], + 103324010102300: [110114001202122,103034031400131,100001010100220,114002114012041,102000004012011,110101100012002,110001002004240,103322000112244,100030220002102,111010024401332], + 1030020201140321: [100032004200002,100020241021124,112342201131331,100010200414111,100121044230002,112003442002011,110010022132422,111000042200101,110043130440321,100244341003000], + 1000112000102220: [100400210010032,110022030110040,102011211321000,102124210200120,112112004042000,110010144200414,102010112000301,101023324003111,102330021000022,100000021221004], + 140131110100120: [102231102020200,102120201140110,100331200141014,110112204224100,100200011002042,102212234021233,110224102230230,100120411200320,112401344040043], + 240420400202110: [102212300202110,100012120201211,100024414212001,100000014310020,100022204300002,101014014211233,100412120433120,101010100312002], + 1012000100224014: [112003001133011,101002240304011,100201134100140,110034100040021,102000221032102,110213002132000,103010000110210,102022201020004,100100424030003,101000131030120], + 1014301024113321: [110212012114431,100001140020000,100012101223021,110031301200114,114002020044120,100021004302202,102202200240222,114102010220042,102021301441201,104103102103201], + 1000200001222201: [110003000042343,100020341001100,110110414402000,101100001100404,110011000043131,100121214300203,100022221044012,110312300010200,110001120021021,1020110000101002], + 302000010323001: [102143124001400,100011011020440,101002121000111,114023314013200,100000201024213,114003422304142,111001404112102,102010201122000,114011042300202,101400031014311], + 213000402300202: [102142221342202,103043404000202,102420000202033,101012400343401,100020101020404,100002411021201,102110010210330,100012020410400,111111102240001,102122111402420], + 114002013020030: [110101210013000,100404121014002,101240220300022,110120020002304,100011000202214,100000024100000,110212214400114,110012101102100,102102304001200,100010040001210], + 1104000001201040: [103142021211011,313040122221220,102121030212020,114411024142133,103004201240410,100022024340200,110230142122333,110010002002000,110204012111004,112311411133302], + 111001000401004: [110002212130403,101042411000122,114101002311013,100133004000124,112440104042121,114200124000134,100224210432130,100120204234213,100003011231420,100222200002003], + 100021020102200: [100113220020101,114031000022030,102014002000401,103103241421322,114121012340044,102104304023201,103310300140324,100002224244002,114310200002400,103211220100010], + 1003012121103120: [110332202020000,112421004012141,102224410201003,110030021010001,112001321113132,114224034000310,102332101001000,114002100024002,114424214144024,103101440121101], + 210212004000200: [110002420020000,100002210401034,112011340213224,101013011030413,111301042202102,101421041100223,102000111122140,100001210000030,101034231002130,114220204031100], + 1031042010002130: [102004004002321,102001010240202,111301022200213,110310012024144,114213002341424,112031000230000,112012240221124,100440310030003,102344100222410,110431020000020], + 1041440213142030: [102301401002404,100232214222204,102012004010000,100040324331403,112104212010101,100001104201201,102300221002020,100002101020010,112010202000202,102033024010010], + 110310001230122: [102311004012010,101020401033332,100012001023022,102112012004120,111321000002001,101210011042021,100042100003104,100004020021344,112420044040112,100100000000042], + 1002022011231114: [100030010422041,114003014100103,112421112010232,102010420200220,112234001100044,102033001100221,100210144220030,100001410012241,101003004000010,101001011002301], + 100041031024132: [102201444044432,114111140220220,114004100011010,114302010000013,100100124003241,100002310120001,100111014231402,110220022111241,114100404000100,100022024100312], + 1100111000121110: [100200011002200,112001112002104,113134002412222,102100311320110,110430002112002,102240030230010,110030010120002,110242024430440,111003212230033,111020404402004], + 100004331000314: [100002044211310,110430122111140,104012302104014,102320221000230,1323100312100112,242022202122014,103014004000240,1140000400200300,101141224002302,111101144404022], + 101014020002002: [114020000020001,1302101004142102,110001001100001,201014000241421,110400102312140,114223013001001,1002000010441103,100111204004442,1300011022000001,401400200400300], + 114000140411200: [111110232242220,100121104300001,110002041102000,103032040110110,100110001201401,112000042002001,100200130430232,103022101412303,103011044000000,100101124002120], + 233020400311200: [110414402020021,101000034000220,114312012300300,101012104210042,101430001010032,112402012020000,103322241400404,103210120100143,101010024213100,100040000123130], + 1124242430341002: [114400214140002,114024022241001,111342314121314,100102014230000,103410004001234,100402022200304,102242024030234,114012434103044,110001001320030,114222010210204], + 111202040214200: [100240000032004,102000000210211,111010204401023,103142444002002,101200010300001,102211300204221,114420232314210,100301004321221,100020000410313,101220200040320], + 103312000220111: [102141401343022,114131304142010,102110314002123,101100020300101,100111121000000,111131124100300,101020204010401,102040111124412,102113100203200,112310231134114], + 1020111021110122: [102343230224321,102112231020231,102320000240102,100042144200000,114201104111034,102310140240012,102030304001101,100020420121003,103020004011414,102102201340311], + 1013402100221003: [100000014102130,100022044344000,140104013031303,101101001020004,110010404413302,100011144312002,110004001104031,100013001214140,110002000040202,110110424221134], + 100002202300342: [102021001132040,110201201211024,110402420402001,110021021210300,110404000000012,102000101120123,110221022101104,110023100402320,100020311220412,110123004401121], + 101322213042004: [114024312212020,103104001440422,114220302314020,112030101110231,103200024030232,111014024112203,102013434000000,101102411114421,110000020042112,110231004242101], + 1022004104121240: [111400124420002,110020402002000,101033124000402,102401000201121,103310421404111,103000020120303,111013232200403,100112044024030,101202024231020,114100042311200], + 1041110400020423: [100200024104410,104100402102320,104133012103021,102200011100420,110020231100021,102102304004203,104132311242210,101040210312111,102210244040143,101100224000200], + 130033111010012: [103012011434022,114103402201140,101313004232122,100001004301400,100031001020001,102111420210110,102104131414203,102203314011321,102000204001042,101231220300123], + 103012141104024: [102113300230021,100010044310002,130000420243230,100232104120201,114221000004311], + 1240030323000021: [114031022302044,102031011441221,102021201410011,114103020221100,102002024000132,100401001011010,100212221002300,102400004021004,102240021302000,103202140103403], + 1143132040003030: [114030110041300,103112004030003,102300001002144,103132424000410,112013102004422,100400220013232,110010002000100], + 1010001102001304: [114343002322014,100022314100104,102130314131401,114100022342130,114300010002100,100013024312024,114002002300201,111012002200101,102102211140013,100311314310000], + 212130202420022: [100313030142202,101221020300020,102013401100100,112210102030020,102043030202102,102300014110023,114230024111000,100402120031033,102103422004103,100010024202200], + 101014002002031: [112000001123004,103400100131022,101004141000312,100010014313003,114100212210001,100022230100202,110100020004310,114143200211211,102002001101211,110112022120231], + 240100123042024: [101042104010000,114000122301411,102111002001230,110410000002004,111424002101030,100414231011020,114121110030203,100110044301024,111100040001003,100042404100401], + 1424233242210312: [102041310200042,110320202023400,111431110000042,110301030010140,102004441124110,103303201400021,114101420030202,114421242204443,100000301221024,101224322120022], + 311001100230040: [114040102210432,100034004211240,102140121410131,112040200233002,102113111343110,103234100101221,114002220010031,103103311424020,101030010320024,100001010412000], + 122322003230020: [110141104201032,103200000101342,100021000101421,102103034000310,110011042100122,102001231131043,112000000212221,143304200441210,101022134002430,112031020230410], + 1000020340012002: [112124004022322,111300210014020,102103201320411,100100031043410,101033214211000,114001100024243,114100012204104,110141112044000,100034244303010,102003104000032], + 1000002031024030: [110202012100020,102303010241010,111342020011220,102230130203001,102021401324232,111222102243400,101004410311232,101201034010420,111220410010144,100001221021031], + 121212143303410: [104130242103012,100002131024210,102000101132400,102412101112121,112023140212112,112313301100030,102110244000130,102101031412121,102313310224103,114000312301300], + 1012030100120121: [102301004011202,102000201100400,110034120023130,102101004002000,100110010410230,112121040200102,103000101240211,114221040210200,100134044003303,110220010010120], + 102303023001302: [100032041021210,110004301222000,110414300030001,100030020011022,114310000001232,111202012222402,102040041320010,103203401400132,103142111441040,110104002010100], + 1000100140043210: [114443330001442,103101041421200,102222321000301,102040244010100,101204444040122,114031030041040,102114240204013,112104222012023,102031021133300,100011301043341], + 1000000230032042: [110102224201130,102104131412412,114020312300021,102400204043012,100000000200102,101011011000320,114420200001202,102100200233123,101012421000011,114023004031001], + 224400120211044: [100002030102221,110414000032411,100120301022212,112203100201021,110000142000203,100013220400031,100200000430401,112203424001001,110310322100124,114000010010203], + 1010240040002121: [102040431121110,101221020040220,114111100021420,112024212301420,102212000200124,100300310140241,100240134323001,100103104302044,102141212000200,102042000222002], + 1400101021431000: [102000001132113,102202310203222,100042001020203,102002320220202,100010044300003,114130210231020,100004410120102,111222214101043,114412142320040,102100044000000], + 101310324040001: [102011201101012,102300304110030,114412000003141,114120430002002,103020041420212,100112011040011,114033300041020,101201220300012,100401024300321,100102030423010], + 110013423010002: [101041310301004,110021122100000,103001224014142,114431224113420,114033012202420,111211002241330,102012000213011,112040004000012,112410214043412,102113201401300], + 1100423401003000: [100004221020020,100013214101120,103321300144024,103241114031030,100143001000202,112040222001200,102010304012020,103131032021030,100004124302203,110200231314311], + 101000020211200: [103111401420301,110124010031144,102140230210111,100011210412002,112004431132202,114130202311020,112120402013111,100434444323300,110230112032040,114031400042021], + 120011030120000: [110204034240010,104102030012121,110000011100204,102110231441040,101021111000022,102100111413012,100113214302002,103442014000100,103021000144000,103132014002131], + 1032020012230112: [110230000000002,110220301202400,100004414101224,101003140322000,110401001002400,102002001130001,103012000100400,114201142324042,102213401111223,100040120000031], + 1110112230110132: [102323304112342,114003222201103,110240020100212,100022204300000,112012211120102,100101040400110,114221002340120,101002204001310,114220200000002,102324004112400], + 1002112332100123: [110301011234204,114211102321011,103330421400224,102000200201422,102412004022002,103220124034124,100032204200023,100023211030203,102104301004310,112000132302101], + 1040000021224110: [114040100030400,102301011002321,101012011022300,110003301213002,103412224020402,112033311122000,100210001002210,102110120202141,114241032332313,112120201101200], + 101122020023011: [103122114004113,102242301122200,110030110122402,101344140314114,102100201400122,100011111022300,114032300011302,100234004033234,101222221020440,100230020410200], + 121012011002001: [101210144014403,102111420233012,110000020022324,100020231201012,102210424042300,100101101020002,110030420410024,111002012202324,402104002030100,101032040320334], + 1004000430310231: [110213002132000,100311221002322,102022420220121,102401214020202,112102204024002,101000131030120,100001301214030,111140000012120,100410040430220,101041404002020], + 1021311102043111: [104110212100123,101200140044000,102214014010030,100021230411014,110024000412302,102331104110040,100002134300030,100130414300000,112310002020302,102002201413004], + 240011130320214: [101042411000122,112041402312040,103023021244000,110104434402221,100224210432130,101002024012004,101421210302410,112030022300112,103100020122200,110241130013040], + 133402201020122: [103140014002031,112003020220120,100043024210301,102014001130100,103400201200000,114021200012000,102422131400024,103210304000030,102340101000041,111201000013222], + 300134100002212: [110224314430000,102203301123001,103100134001001,103210400110122,114030314123101,101201124013202,111322012202310,100400201010000,100010321043134,111220020010043], + 300010200313412: [110202210102120,114001004100003,100041014102004,110320022101120,102131421000411,101412030302001,102222021124112,114000040031021,102400001110113,100404201012020], + 1030111104004221: [111220204101421,110042120021013,112200420200200,101001010300011,114012020044224,102122401340101,110021020001220,112001024000200,110112030401012,112020012002031], + 100341200042220: [110000202003120,100130220400000,102312300220000,112221024002232,101020111140040,102041111130300,101042200303012,110401202021231,100240204101020,113020012400412], + 133102000010222: [111130224102101,102322020212020,114403304140021,102103021340120,100031131042030,112201422040000,114021040001000,114024130031020,101220201000030,114022300011000], + 130044324004400: [102303110220130,100124120011100,114003004031430,100220304220004,114110000214110,113004001021230,102411000200112,110332432020400,100120120402022,112110322044020], + 124021132014040: [114021000012310,101042410301221,110432300102000,100011004102400,102304000210204,110040344210011,100020120101000,100003200020112,100400231000200,112143144020012], + 141004020022004: [104140321242022,110020004422304,110310000104014,103204301200000,110122022041331,103010311410024,103403411212300,111102412112040,102230002023220,103012041241100], + 223001001300404: [102000140200220,114233210000201,100002001024100,102103130221330,110011002100114,114102220033034,114004020020313,102022421132024,103303041402240,100002121021022], + 101211101320010: [110202004211120,110223224433004,110341010044330,102031144010424,100302420120212,114004142244000,111212114131222,102140001441301,111012030022123,110000011220204], + 1003120112012004: [103220000100202,103122224034122,100142011002402,114004200021000,101302331000221,101111440324120,102302221002020,102101114000401,110102002120401,102124301120200], + 1114204043000300: [110312332102012,101404204001310,101003100302100,103000331422023,101400101100001,100100020401310,101040234210040,102003424021402,110021330033102,101002034003411], + 1120100200003322: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 1124101002002300: [102001404012100,112004202302034,103300004021200,102122214131011,100023031000024,103230134011412,100020004101012,102402000201011,102311011000200,102021021101204], + 123002100034100: [102422001400000,100301224310100,103002104012101,103220130211414,101020220323012,100012324202240,112101102012030,110003410100312,114000022300301,114000000021100], + 1003011202213222: [101011004212201,110032022002020,100214230430124,103031234000122,103230011412301,101042001021012,101100104002023,100400000010020,100124021201021,100102001000000], + 100130000013301: [114020024120310,121021032342113,110220210110004,1122204031101014,100003204214031,1100220200041014], + 1001121021323132: [110112102211042,114200022300033,101400220303133,110431442110400,114011120021012,100100111041320,101420010300310,110000004210112,102334001004100,104100001240034], + 1012100044011013: [111101010010203,110110212010011,103120101441202,110011000022102,101002121003112,100004104210221,102202410240103,400014404414011,100030211040004,100000010101402], + 133020140000230: [111102110012000,101001400301113,103101024004200,101000344010212,103300021402104,102100431342023,102102024000001,100104400021023,114003104032034,102020304000321], + 1140232120001101: [102000144014000,102100104002302,102120010230031,111202300010010,102020304000242,101232321020000,110002400023342,100120044233220,103402201212100,113031010134002], + 132103142201004: [102300324010203,102100142002204,102040011121100,110113004402201,100030024303023,102042204000300,100001134100120,114023214101310,110301232000100,110102400013020], + 1100412112100411: [100041200010000,110111001300044,111000002202324,104132100011024,111211010001300,100113434301241,114030020020301,111014014401303,103210001422303,100100000022131], + 124031212031103: [102110104004031,110130100010331,114004004100022,142100000024013,110022000022202,114300402320043,103110214004242,120002222420113,110404044220000,101010211033230], + 1140002323210032: [114000102240100,103200021401030,230222010240012,112102121020220,130300100333301,100020120024010,112042042001002,114102002344100,100011204340230,100202400002411], + 1141001143204003: [103210400110122,101112020300011,114104302341000,100400201010000,100010321043134,111220020010043,102100021342024,102244400201444,101010001000121,101232104040130], + 1030021010204101: [102020044000030,100002001022412,111202320012012,100003001020010,102442004020131,101011124210300,112101422301001,101301220311200,110040014213300,100320421002220], + 1020112001300220: [102000020223013,114040102301100,112121032014014,102310111001210,100020241043022,114413232320000,100100001040134,102100121341102,100002004130101,100301024310020], + 110100401302202: [100103200020313,110000431213211,100414024102342,101120120330222], + 1003232100422034: [110104231221040,100042110122000,114400322311044,101021021002110,103224401422304,112112122012022,100401140033104,102120100212020,100020114200220,102411130201102], + 1004201300020013: [100001300102001,100220101204311,112033124022002,101013114001130,110022134210202,110110102042312,110440211340302,100001300000022,101004104010020,102001014003100], + 102012021000021: [111101122102222,110034004420011,103000114001000,102242024030234,110141201000200,100003344214000,114400300000221,110314014422011,111022214113044,103104024000023], + 243300413202000: [110041030411301,110001041213031,103301210142043,101110044200100,102411000200000,110414300030001,100030020011022,100400014321101,114100122342002,111202012222402], + 243103020000241: [110020402002000,102042221101230,101033124000402,103310421404111,102101134004010,103000020120303,100112044024030,103240100102101,101202024231020,114100042311200], + 224044330400040: [103102101422031,102130124130100,112404002023002,102022020204430,103214021400010,114003422304142,100012401020212,110100022010014,102042231130200,103144220102102], + 110124302311002: [102010011411233,101030114211022,110033124420110,112002142310023,100040101020201,102102240210310,114231220004002,112020300241320,110410012020110,100004424230021], + 1100013010001240: [111020044112020,102004404000111,100020040101021,110100312012040,101104312040120,114044400021021,111412122101012,100003200100331,100000124200111,112220434011000], + 130010402030010: [111102440020002,101202001024340,100004000102302,103312010113222,110130022140122,112002304004203,100034110413403,101030040320021,114104000002301,102232110201100], + 1000102120101030: [103442110132330,102111310313001,100203010434220,102140322001242,114023044020211,112013124020300,102202321114004,110401214221203,200200133341004,100242001200000], + 1141200320010130: [114213002340022,101400104042212,100000021022400,144200203310100,1003022312322100,102001244001224,114030214020000,102023422000000,120101041020020,102330204110410], + 1010204301300213: [110200400000020,110203131211112,102301004110004,110021100023210,103122000100403,100002204340200,114103412201420,111140000000000,110014300041302,110020041310021], + 200340341310214: [102130124130100,101002121000111,100000201024213,102022020204430,114003422304142,100012401020212,111001404112102,101400031014311,102110230200201,101240404011020], + 310020203111444: [114120030223400,114423312314004,100340100424220,101202014010412,102144031403200,100041004202111,342003122142040,100243404101011,110421104220200,102322124112422], + 1000221100000124: [100000410103200,100001240410410,101042201000011,102030001412241,101001204010220,100004301023143,114223200221140,101012400304201,100031044300340,112004021121002], + 120242012440140: [100111334330000,110023240021020,100300433210004,102240100011000,100400213242110,100020201002004,120021202100230,102320120240200,100000012221111,110102301010411], + 1140023440311401: [100430211011410,110010340040012,111010124402202,110211020121140,100020244310231,101000030321102,102110320210011,114221234002100,100033100101240,102420001110301], + 212102030132222: [103312010113213,110020240022142,114401212310021,110131022111320,112000401132020,111302014120120,110013034211021,103001214042003,101020241021030,110020001300000], + 140241400202022: [103010021422042,101110000010122,102100404000021,110323002022000,104123302100200,100103414300020,110010121333141,102402034020001,111202324134000,101433201010200], + 130002021100101: [103003001400110,102143011343003,112022001120410,100341410422102,111002012200131,101400040330021,112210001102424,110101321301120,110001032002011,114102012344003], + 1000300014100040: [101020044011003,100021014100124,100122040012210,101040000300110,114202124000200,112041432030144,114000120020004,114241110000102,102140214001144,110200202121001], + 1142021241010010: [103000011402201,110210134244100,102121041441000,114102022200000,110233010002020,111203034103022,102101304000012,114020202241323,110004402131000,102132421000100], + 1121140022033000: [100121230031032,112000431120410,103042024040104,102304104110001,102000200200301,100104211044110,110200101200402,101342300314204,114241222321321,114013124030022], + 124402000221041: [100000044204004,101020224210014,114202244101041,100122310020400,112423102010012,102112022001414,101212214011134,100001121023210,100012101020002,114204120000200], + 1040033030201302: [101230111024130,1112100200412130,1320100232411004,100121120102303,1020024112001010,120100010104132,423203002400042], + 210001020023030: [111102104100334,111210014102030,110401100001104,111440000000202,111200344442041,103141001240021,100001401034130,101220200304110,110420014242010,110403102222001], + 1101432000001304: [110230000000002,110220301202400,101003140322000,110401001002400,103012000100400,110210024220020,100401424300314,100040120000031,114200142324000,112100322040040], + 214414123000031: [104132340011314,114012040020310,103132004002242,110000212104130,110200200004002,114131040224332,100123020032031,121002023311103,100021124203441,102022411412401], + 1002100411213122: [100422000031421,101214104041040,110104231221040,100102000010243,112410034040040,103031410122401,103101000100022,100040021031201,103000300120001,100020141044111], + 1002400232420012: [102004300220000,102010212000134,102110021341422,114241022332104,101403020334021,100010001040104,110141020400341,114133102311014,102341204111304,103211001422023], + 144212103223430: [110011414240022,111142010020301,102100104000040,100000144104100,100010044300003,112120224040040,103301410110110,112114324040000,102124031023100,100204104320231], + 221340140432000: [101220111020012,111401200000040,102300122004231,101041204222101,100024024211001,102110001342114,102042444010014,102330311004110,114032110040320,111203012221030], + 202331013000002: [110100100031014,114001002300430,110411130100013,100021044210012,102212034044212,111341300011434,100401304302243,114101212202230,100420001001112,102140400210434], + 1000223001223311: [114041400010321,101002234002002,100000310102011,102220130204110,102331020242011,102012030220314,100244244322120,100220034341000,102101134030334,102103202002232], + 120022010300020: [101121211101004,101114101012020,101001304001101,103000110142041,102002112041034,102041111020030,110022001201023,103101124003110,112401144042000,101222044204000], + 1100030000444204: [110013202003320,101031241000010,102120231343224,110030332100203,114404232310120,103100034001310,114002202210331,100031301020100,110111032140220,100020010200022], + 222201234100023: [100002001013012,114120220214130,100002200001011,100120001204102], + 112310442004211: [111030124112220,110000230010221,110202110113000,100324114310222,114001020022140,110002242100100,114012004020230,110000104211010,101022221002220,110220400401033], + 130013314023140: [402000401204030,114124020222032,100140201000222,110110000004210,101400010303002,104200202141001,130030220200012,112200110000221,1321002023100013,1103040030102440], + 1010224102021001: [101240220300022,100011000202214,102200130202201,102002020220000,100102120422002,100002010014040,100001300012442,100022000410041,103020000102011,103001031420203], + 122430102020402: [220212211200433,110002144411414,100003024303000,101204110411102,102142302000411,103222440102000,102440420200031,110002241012102,100131100001021,100000100422002], + 204103001102322: [100440031001120,102020200223310,103220011420242,102032012000101,101001400301113,101004201001232,112102102302000,102141231343401,101231104200000,100002120200101], + 211130330201010: [101221414041100,100032424312011,101110301040312,102204010204023,103041020101400,111300402200003,114141024004011,110022341300320,100210301002021,103040000000212], + 1113002200100201: [110041030411301,110001041213031,101110044200100,102411000200000,110414300030001,100030020011022,114100122342002,111202012222402,110033041200104,102000221442214], + 1010010411302200: [101010241003223,102000020220000,114412142320040,100003044100101,114012402332300,102220211122102,114420022314022,102234004010003,110204314402021,103121004002210], + 1044002110020220: [100400224300040,111144042240304,102000131131100,110201002043201,102400021401101,102141201342300,102140210230000,102131211411102,101001004012413,102024244002012], + 1201222201213002: [100110000410200,110120200030233,100132040031022,102442004020131,110031010430100,100432431000310,100004000014032,101014121024142,101001201022304,102104004002400], + 1041121212311212: [102000221101002,102000431130020,103102314001204,103120004004010,103222120102031,111104404100200,114432224142000,100202234320210,102112400210210,114001332210232], + 100040011201012: [101230002122040,101210241204043,104102040011120,111311120014011,100123011004113,100420001002101,102430121110340,102020121102120,112141104020201,102000024000002], + 1100100120201300: [100301301000024,102020111324200,101044400300030,100100310024040,101024024002120,103212010100200,132224022200202,100231004331011,110203002102023,103442121212103], + 202310400211312: [114200212322001,100401210020002,112210322040121,100402042200000,110001440041003,100010111022102,100220300410430,101402010301000,100000220111021,103140120112001], + 101300043401010: [110101200032041,113402202420020,100000012212010,110041002000220,100040111030202,101142410330304,103110001242101,103431011210021,111132304100420,110433222223310], + 1120000022102114: [100321004011041,110002342100014,110021312002040,111101042244210,110441010002400,110124002040002,103110314000100,110023410122402,114203104001000,114302200014241], + 1002022101340120: [103203224022224,100143200421104,110213010400012,100123221201001,112313000202012,114022114010220,100010001043004,100011410400320,101112020330001,110102101002040], + 1020421022112102: [112010032340022,114120304000212,100141410402200,114111202313213,101042041021001,101211414040000,100010031232443,100242024100000,100114020414244,100012404203210], + 1400020342002003: [112012000220043,102414000203000,111101400022211,111320100000001,112002202000010,114001102301101,101010041003004,102000121442001,114011020020242,114030100040000], + 1021420024210010: [110431442110400,114011120021012,100100111041320,101420010300310,110000004210112,102334001004100,111321424123422,100004000002200,100001140411014,101312014234200], + 1410343201224101: [102242304042410,112032012004300,101001034002001,102000201131020,1010120030012200,101024411001024,221104221024023,100010410420002,102123332000002,112000034000041], + 1021212301002021: [114104200220022,102010244010000,114430412322343,100000430014301,114010134021022,114102224104002,100040240003341,114422404110312,112140134003231,102403144000120], + 111012320010012: [102000034011002,103204000110000,100001014340021,100000034312214,102103001340022,112032000211000,134402411001001,110032020020001,100002110000131,112021020220112], + 132234122213020: [103040014000114,110012040030401,111020142230010], + 1040111100100000: [111122010010414,102040404041112,114140030222402,103331304032010,100121311021322,112301120200041,111003302200334,101000200321321,102440000234100,103030100144420], + 1130210231004021: [120402022102021,114400210002021,102010002000402,114201402332241,114211030021301,210412232040000,114030214020000,114022000013011,111232232222210,102230104030012], + 1003220132012024: [100030204300220,101021334000222,114010122330030,100011024201101,111222442222413,110030122102303,103044001412002,102211124032000,110400200000240,110101301000001], + 1444200133302110: [100101024303332,100013201020230,112300101101010,114301302323032,114200304000002,1300040101002020,123310121130130,1001210043013022,143442111023013,1022003020311200], + 1022120000030130: [102040431121110,114111100021420,112024212301420,102212000200124,100300310140241,100240134323001,102042000222002,102001011100100,114402104142102,100030010102102], + 101000000200420: [110020301220324,103040020122332,102020100243032,102012200202303,101110404021211,103110041442122,114042014102321,112003110242131,102112222001200,100011114300032], + 1040030020032021: [101004200304221,111203102223243,114221334111220,100010034310013,114311400000224,100040101001132,112211132040204,102113232001100,101110044000400,102102021002000], + 1123032011000000: [111001000020034,112011041110422,101410014021040,110001032010100,102242210200010,114422214113202,1100020120011024,112411210202004,110002421122010,102001200200221], + 1024034310220010: [112413224040101,100220100110400,101200031020230,102403004042342,101024001034211,111122004101222,114020040013100,114001012300002,102121100232012,114000222213021], + 1120120243000100: [120101012430440,103102124000030,111000324110232,103402001200000,100400120022020,102120300203403,110323300004120,111102204403003,111401114423000,110010120020200], + 112100410221222: [110002004410202,102103114000024,101101410010023,112041002002124,140343100002103,400200234320200,101041200320322,100020124204330,110200320000000,100001424102041], + 1000100012210014: [103134014000340,104103100010141,101440004041120,111101222240010,100040210411102,101031214000041,100110004102034,114112020212203,102040140220220,114300132321233], + 1142300113030404: [100022041030000,102202000200010,100010430202422,112340020203003,102443011400041,100010430022021,103032441431121,111300030040030,111003000041302,112434400204320], + 1022042041011200: [111110214100223,100012000414010,101200020300410,100110224304220,102330211001002,114002110022030,112211110200310,102212141112000,100023020200332,114020204100242], + 121221003240413: [101211201202134,103120104030100,102020030220200,110100440400010,110003434410403,111110000014401,100000004130010,101300204230000,114002004100140,102311020240020], + 110300322300102: [102130411411444,103103204000110,100441301014410,102404004001203,114001024010010,102101224000013,111212204420203,114230020000033,101012004002440,103110400120002], + 131134004004000: [110110010022302,103000431240102,114011004114100,110101140002212,110420000104020,110410140000110,100000401031111,102004101410420,110204242124012,110022301301002], + 130232344011120: [110011011212100,101134030011000,103220211421421,110123230124040,131000001020102,100044130000101,110420001000202,100102110402220,110412310030001,114012022302022], + 122201020003224: [110441234224400,103100014031411,110000300424304,100032121024110,110013122130200,114020204102020,103121221400012,102022400211311,110030400004330,102004204001111], + 132444244300220: [102140014000020,103011020140013,110030002102021,112200401102102,110304200001120,110022042000121,111122104100001,110402324221020,102412021114100,102110004030420], + 100240020000010: [100001044201401,103022120100401,112411042012210,100110444302011,102142140210001,102000202041211,100211004220330,100000304104221,101002104004003,114124004001310], + 1023120202043100: [102104002004301,102144002001232,110000221223422,102002104001004,101440001104012,102441140234014,100411130430221,102344004014110,101120121103012,111032102202040], + 1004324022323001: [111000000010022,102040001123104,100210414104124,110403022010001,112110001103200,100204004123220,114300202300030,103401140121121,112100122010004,100100240010030], + 100230002202140: [104102202102142,100000401022041,101012310301211,101204234044003,122002011010101,103014134000300,112001002030020,112030200241011,112034002002000,114100202203044], + 1422202204201044: [100310304310342,100010041031020,100042400001023,112402000200101,100020201221000,101010020301243,111010130022401,112140214000020,101310000314110,100013111020021], + 101000000100031: [114210100002014,114440140000234,100021100420321,100400000020412,112230002033202,100401222201402,110000001012100,102101011123100,101440001100100,111210200002411], + 1023401013100200: [101230002122040,111124004101012,101210241204043,104102040011120,114103220220104,102120004001310,102430121110340,102020121102120,112141104020201,101200111020111], + 122041001000441: [111320012221132,102302144110440,102143202000400,111020002202333,101321311004010,102110241342210,100002320411400,100143034304100,114021002331014,100100104102112], + 1020020021012120: [102001404012100,102302200210010,102340120222440,114223204100010,111041202200140,111300400002313,100023014313010,114021040010311,100020004101012,102402000201011], + 100202040412040: [100043104240004,110002034200042,100001240100033,114100304002030,102100001340122,103414101212410,100424030024330,100123021223100,112302011102312,102400041110112], + 1003022434000120: [100200101000000,103110431441100,102101324130010,100011200121231,111201102224324,100102004100201,114040020021023,111230114102201,114201102342110,101400300300111], + 130220041030320: [102200001120020,100004400410040,100004210400203,100002431220022,110300102021320,102301221102000,101012004001204,111411000030222,100040011020200,101414411104011], + 103103120201012: [103000004012003,114000014014332,112303041103203,102101024022111,102020231440400,114030304122412,100023041030400,102014011102400,100020410124020,101013200321014], + 1004022310201032: [110004301222000,110221000111302,110022140120012,110024140142000,100321001001010,110321302022203,100002204310140,110110210011002,110221322123012,100020320002000], + 1120011002410001: [100034204311021,101121024024120,100102204231301,112201104011200,103020420121211,110341024422102,111031030040220,110024120430323,101403200302022,111400102104003], + 122013003210012: [103102011422101,102412201400413,102201102000000,110022000442031,112140202302210,110001042012030,100200104102011,110432132110010,101420304041030,110040222132423], + 111110310130240: [102231130213210,103214010102022,102000402041014,100043324210140,100023024211011,102404021403141,100003201021001,100122020011232,110002021121023,111102042213043], + 102331242012033: [100104341010424,103142210104020,114400240003003,112203001103411,101022001002030,100212024121000,101104040302120,100010001032200,100221110101420,102441030231300], + 1002301200031033: [102340221000300,101000130320340,112401314040311,100110020031042,102011004013000,110422102110221,100220124221000,100402002201002,111110004402021,101011014002032], + 1120212202013102: [101201000300102,100100034002202,103102111210103,103420240124040,100120110111021,112121011101002,103111010120121,111134204101221,110241211302001,110140300034040], + 1021003340101023: [110002302010012,114444044140220,101212001204031,112100232040011,100242011002002,112032410212442,110021233042220,102002200222041,102404414041110,102144044001000], + 110141003140201: [110124012142001,103110044002000,100000000413211,103024214000000,100403110022202,100021031020121,100001104100010,101013004000002,103131021420001,111200230002002], + 1024120002020144: [111104102242110,102210011101414,100002200410230,100044010200300,100003010413400,103334120114003,114032124013234,110112131124012,102143020230411,100440221001232], + 242303322114230: [111001440020003,102020204001132,110200020010003,100002214100100,102120104003011,102100144001112,120020201100121,102000041441002,102120402000014,102000200210032], + 1010342240120403: [102001404012100,1010400230221020,102302200210010,102340120222440,111041202200140,111300400002313,111101040014040,100023014313010,114021040010311,114140004123122], + 1144043310022002: [100042301001230,110002240134040,100040014310020,114000014100101,110031324200020,101110310331140,100300001003012,101430021010144,111210412213001,110000022201310], + 1120001001311304: [110100120400020,102113200210140,100031021033010,114030000030012,100000010202201,100012024210210,100120004300001,111140214103110,100010201030330,114022232303310], + 1403112003023002: [114400022321400,101302340312230,101000034000203,100200321200200,112044200243000,100002300421000,100202140430012,110200301210031,110000420020100,114304212302401], + 302212402010210: [103211200100400,102112231020231,100022004300020,102320000240102,100042144200000,114113104123200,102030304001101,100020420121003,102300040221403,100114021040000], + 312003244021002: [103301210142043,101110044200100,102411000200000,100400014321101,112012020230301,100010101020023,102000221442214,103142111441040,102140101343110,102242000200420], + 114400102222313: [111100114401014,110003112130100,110103011302220,102020440242023,101230000302304,100030021041110,103222010114132,102300121004102,100042024100140,100110004332200], + 132420000000431: [112020200242131,110240024241203,102020204010103,112432120204400,103130044003012,100022214101010,110001340112402,100142221013104,103040421244210,111111014402340], + 103200001210003: [100000241020300,111021030042411,110131011000142,100201134320102,110000302122001,103302031401001,110202012020000,110043414212400,111110004101041,100402000010424], + 220414040300300: [100202030140400,101024130300401,110010321011300,142011423130201,102000401130243,114031212300003,100442230030000,114002132240212,111001122224141,100000220000220], + 1044310320020000: [102144201343034,100430010431044,111020122230001,110111221000100,102100204000340,110330221300223,112020442310202,100023001030212,114344200014300,102240001302103], + 1420020302042323: [110141201302122,100000411231000,100023001222000,101002124002220,100101004230030,102103012004030,114034000012210,101044004000132,114114004140010,101010241113102], + 1012010000131300: [100122220023132,110204002043423,100032101220041,112003011121310,110110110133103,100130101220012,100400030022020,114302144020021,111012414402104,114122020031041], + 1000202200021220: [100000144201001,114202202322132,100000011032020,102022201320204,100002111020330,114432200001322,101040404000121,110300230102002,110103032012200,100010004340042], + 1040004023000010: [114200402332011,103240411403020,100020101031131,101010000323030,114200202330330,103101101440200,102142221401140,100000101031020,114000002302313,103012201401210], + 1010223022000012: [103110020210000,101420200304000,114024102212214,102102000212010,100233404320202,102210004110000,101142420012223,100000004204012,112214024003000,114001410022014], + 1120114042002241: [100020001044100,1340120100441224,1301223001003430,232020104433104,102330042000001], + 132302002220112: [114110200030200,101012130310043,114001310043110,114102344121242,110110104204000,102010021132200,102011001411100,100001410411142,111010020021202,114003300023020], + 100000120212142: [110021040020010,100001140020000,111011030004021,110013030020121,102001221100211,102100132000411,100121104300201,101220330300003,110132000024420,100011014130012], + 1042404102220010: [110034300021014,101042401000112,110230010000000,100112440013034,100011014101313,110104140001020,102011114000320,100041001211002,114200134110042,100204304122112], + 131110144032023: [111000024110140,102230100201001,110000401221440,102410104040240,112314301103022,100020004210021,102000222003200,100001040020122,110104101220110,110112211000311], + 1010220000431300: [100321004011041,110002342100014,111101042244210,110124002040002,110023410122402,111204200002001,111200020004203,100141101040300,103000104042400,110000011012202], + 1020310100100200: [111000022202402,100430211011410,110010340040012,110014032101430,104421312102244,114131014101010,102240214041033,114200322333401,103010021422042,100000001022401], + 130012120011424: [110010130000004,100000331040124,102122022000230,101011200324311,102301011004011,112030040242300,112400002021310,114030310030022,112224304041202,111103044400100], + 1024000412011400: [100031300002022,110210020002243,110210022120040,103002044002032,100101020402424,102201112000001,112211120202000,114211040011201,100020100423404,110001222202031], + 200000201004010: [114010200011100,100102110412002,100000204214001,102013024000211,102022000220004,100012001042030,102000404000400,102004004004200,101002134011001,103440411210000], + 124002021321013: [110412220102021,100300004310110,102002400430000,101200124200010,102143120210003,114310012300020,110003212104043,111011022203010,100001000100020,103211021423243], + 100230411103001: [104100202101022,101131141042121,100440000031023,110012012004102,101320244221142,103100401421202,100002211221402,100103301000402,114101022341020,110340122100210], + 1101210003102202: [100032041021210,110414300030001,111202012222402,102001301120112,102040041320010,103203401400132,103142111441040,114142044120310,110220410000040,100012000022003], + 100034000004222: [110001422030011,102144314002302,114200112340002,102343014022001,100211000430431,101213240301002,102240320200212,100140200410200,100020020120200,110210001214000], + 1101441010123430: [102021001132040,110201201211024,100032201024101,110221022101104,110023100402320,110123004401121,102032020214001,100040341020133,111101344104210,100410220030300], + 1024401021240112: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 1004230232322310: [103212014020132,100102101000203,114111200034310,102231301122300,103230040101112,102001004000100,111121104100004,100010041032043,102441311400421,112030004021010], + 1011344010300421: [101214200300004,114330120000222,110001440004103,110010022202202,100003030202011,1000301003020410,1014111023013000,110320044420300,1003300020121100,110201430400400], + 1122011114203300: [100000041040000,103004104003011,100101234301300,102331104110040,102300010242203,100020410410021,102144002000300,101233320302120,101421000304101,102011204023300], + 134041034223422: [102334004110232,103013000104404,112200102024122,103000034003300,112300032000100,101000100322140,114010010002314,114124002341030,110302322102041,111300202200414], + 1121000000204032: [102210011101414,102102011401410,114032124013234,102143020230411,100102014301210,100001000410200,101023134002011,101000131030300,114241402320044,102334040242404], + 1004201441103122: [114014112300100,114030034013101,100000044204004,101013004001421,103000014011004,101020224210014,114202244101041,100122310020400,112423102010012,102112022001414], + 1003040030421401: [103011424002021,111121204404010,114210000000224,111202112220003,102311110211420,122210101023210,101044111022300,110302241332230,110002004410314,101012000311412], + 1111110100002020: [110122120100022,111100424100021,110111121011004,103001020104102,100242444300104,110002202001202,110200422113400,110022300021012,112000000223310,100002214210110], + 1000000010122041: [102304340220231,102103440200402,101014424224002,100043000200103,100142401040042,114001032302222,101013404210010,110230000002324,101401304040214,112003011110221], + 1411020222201202: [112002110220340,114040210021100,102002220221002,114100234004010,100030410102000,112240334012440,102101010210022,100010031222001,110020200001031,100034021034000], + 1410002000001121: [114211010000210,110200020110120,100003040101420,101440004020212,102234400200230,100000004210012,110202102231202,102112000204313,100224120001302,101000330304200], + 1030012012011004: [100010400022200,102300001002144,102302444110110,103001000142003,110310004424232,100402012200112], + 1042202003423010: [110303120102044,100131031020002,102323304112342,114003222201103,110002022030224,100204011002001,102013301320044,100022204300000,112012211120102,112300000204010], + 1141404023020000: [100004001021111,101021004214202,103022021431010,100003000104203,102101220214011,102114320203000,114001112300001,101003104212220,102120231343021,102311110240101], + 1041400120014300: [110220202124002,102030024010020,104100212101210,111320000001004,101101021110401,101004204211203,110002012000001,110201002040204,110010402102122,100300024313211], + 122420402014110: [102000421131000,114404020003022,103100114000000,100421242201010,114410212320200,112020011110100,102030000221301,103300010110424,103020011430001,112000002000112], + 1023021104102301: [100001201220014,100210000032400,110200422121211,101213311020021,110040411222022,100041120200010,102303001003004,114010312213204,100400020022321,103211000211000], + 1100040012201200: [102020000204032,110000000003200,111401200000040,111202004100121,103230104003200,101041204222101,100024024211001,114031000012100,102110001342114,100222220001202], + 123003311204111: [101222321200012,103211144033404,103103240104001,102123040212103,100204104322122,102100011341012,114130000220023,102314224010213,100000120000202,111100230023321], + 1033101124442100: [100313324320240,100001310421201,110000110021420,110100410011143,112000221133021,100130000010204,102443324020000,101134004004013,110401020100113,101214311020403], + 1024102010130120: [102020000204032,110000000003200,111202004100121,114031000012100,102110001342114,100222220001202,110200000004322,114342044032200,111110020000001,100200024323300], + 214432414421000: [102100321320100,102102011414242,100041004100221,100000000412112,110000010033022,102330040242220,102140121410131,102310400240000,101201340300430,111320312222220], + 223412000312023: [102100004130301,102113020210120,102201101122100,100102114100420,101012310342300,102321320224101,100002404310212,114012212302132,100430324300003,114230222331120], + 211012410102104: [114404220000142,101100214003002,100021231022220,102410420230111,102301220210011,102120004001102,102323210221002,103211001400330,102410220200400,103020210143120], + 1002023202310442: [400004112102010,1200020030443142], + 100100002221212: [110231434430114,102340144111123,100140010100100,130011204200020,140243003020120,100120014301440,112020240233004,102144311342041,120422012013021,101040400300024], + 1044010413203120: [103130021444021,100022001040322,101400004022210,110020030024004,102112204131410,102312301104422,100000411002023,102303200241200,100022021041122,114120140000100], + 1400100210120201: [104100012102004,110000010120043,102102011413000,102403404004110,102031024013013,110044020020202,102122410220401,110301311303102,110021232000021,100001140000010], + 1040312010102100: [100004211221210,110201001212001,110200134240420,110403221000002,101201304200320,114022042302201,112002320212232,103310101401010,103140021401211,102404042001400], + 1000300001000101: [100003011041040,103200141404212,114001112300222,100203141001002,114122440000024,103000020103121,101200024010043,101044211032201,100011111032203,103021440122032], + 201034002100400: [110003004410041,100000444104204,100014420000000,102012004013201,100104004230031,100021000021202,101400000302113,112211030201201,110432304221110,110410212110111], + 101101331204020: [110112012140003,112110220202020,112002012030102,111003410011000,100400100022002,110300200044430,110401422114111,112020021110112,112120020220421,110220244403201], + 1122221100001000: [112023022001022,103122221240032,110310022220010,102001000202131,101020401034111,111012400040302,110140021322121,110120202212130,110013140003302,110220002040001], + 1020000002421121: [100200011001220,111202014132111,100003141022321,110201434240143,111030044110010,110041304201404,100040211022000,114000134102201,100420104301012,102110001401111], + 201022410220300: [102020410220200,100013014101040,400204300024034,100402010420301,102022110202024,102010140220011,1002102003210222,1130420100342202,102120000210110,140020100011012], + 1001100100001221: [114203000004300,103140044032100,110322100104010,100032021041010,114100004121121,100040214102023,103033044023040,102403101400210,101000001001104,102100330231011], + 1424104010001321: [114213002340022,120402022102021,102120140212001,114400210002021,103103221421013,102010002000402,100240011000013,114233112330324,100000021022400,144200203310100], + 1403010413000123: [103142100103020,100100014033224,101002204213002,112001002300102,110002402130200,103144111211103,112202002030000,110100001014012,112243034012420,110010344204120], + 1022030220022102: [114022300022421,111210044410020,111420230003130,111310004122000,101221000312044,100400240013333,111001314111000,103100040210040,100210001002200,100001210100102], + 1104301030300303: [111220002220100,100000241020022,101133410300302,132200010004401,100030044202001,110114410003233,140200430112430,110012030002010,110000040024442,101410044021332], + 131420104131100: [110230000000002,110220301202400,101003140322000,110401001002400,103012000100400,110210024220020,114201142324042,100401424300314,102213401111223,100040120000031], + 202204411100110: [114231202331202,100003021234044,111102032220111,110200204224211,111300042200340,101010041032322,114020042300022,100021421020002,102400004040100,111120204100203], + 1111100011232413: [104120011242011,114300000000002,110020002104100,102111400202120,102000301101102,114100124002210,111122200021102,112400034040002,101041100300001,100000020201032], + 1002000201011131: [114200302320443,103100420210210,102132004132023,102040240242204,103224020100300,110030012000101,100403220022142,101001240310031,100000101022200,114030000024010], + 1004104010000220: [102231130213210,114113104123200,101210210300031,110002021121023,102300040221403,102201100200430,100114021040000,114121300224141,102301100241002,100021020412110], + 1421021020110001: [103132204001001,110003404411303,114410010001200,111211232220002,100112301000311,114000142301404,111301032200412,100210011201011,113030011000324,110100120120001], + 200021104204110: [111120230020122,114301000000002,112124310203104,100113324103000,102001000221124,102023021321020,102114020210202,114040204014042,114001010044120,101010111033143], + 1120310000031004: [110411324240311,101011034000230], + 1112021100202003: [114031004020241,102430321112030,112101432300231,110213042222211,100320224314301,114202032320004,100040014101440,110321100100401,112200102033440,110100000101440], + 1102000220103034: [110011414240022,112004202302034,100042001020203,100010044300003,114130210231020,112120224040040,103301410110110,102124031023100,100204104320231,114002104020100], + 1440232013001100: [103012024004312,101040040300223,114234004000210,100100001040410], + 1110140020111223: [100321004011041,110002342100014,110021312002040,111101042244210,110124002040002,103110314000100,110023410122402,114302200014241,111204200002001,100002300411002], + 1222102001102032: [110200321303322,100010030100011,103002041402004,102022024000100,102103030210003,114120034123300,100040001230110,103010011401200,100020014210002,114010112332112], + 102121400201014: [111124004101012,104102040011120,114103220220104,102120004001310,102430121110340,101021204000200,102020121102120,112141104020201,101200111020111,110001200422320], + 102010300001011: [102404004041224,102200041120220,103220010101140,101140014001001,114101002200223,1034110304101100,110021041330000,114321140000202,121102001120113,103322000111220], + 110101402310010: [114011302301400,102304034110400,102100220210000,112000022000300,100003214102204,102430300201034,112030122000001,101102104020404,111222024104240,112000102000001], + 1013400111031002: [110300222104222,100002040410130,100440001000012,100403011002204,110202414214022,111002420031340,112432142020024,101103012130233,102320304030000,101112241010002], + 102003130120100: [100001230201101,101101131132022,100010100000042,104120211242040,112220104002000,102223004042102,110410312121010,110330130010041,100030034303012,102422200201100], + 122040420010323: [114203042330220,102102231400111,100032421040120,101004201001232,100000400412200,100002020101023,111100232241200,100011234202334,102111024004010,103343010113030], + 1031013022303011: [110000322130121,100200001210021,103204230111030,100422211004214,102100000210002,102121010210004,114013214010111,100010004210020,112002100240200,100001404100110], + 221002402022003: [102021401410001,114210410000401,102002410222340,103210214003143,100110000020111,114401000004202,100024104100032,103303000112122,102100014132110,100021304103002], + 1001100210002400: [110322104424202,102112201020000,102102220312102,103004204021310,112220102043102,110012310020200,103030120100220,100232224340041,112400002011010,112011001113222], + 212002400114144: [100032041021210,102040011121100,114310000001232,111322234130000,110104002010100,100030024303023,102042204000300,100001134100120,110303401230040,110024140142000], + 1120324010000221: [114040300043111,110203111111000,114010030024204,102010201012014,102041204000002,102323204112320,100402201004014,100420404320101,102123414032304,112401014040034], + 101031020122412: [100000210100030,110001440041003,100000220111021,101000430320220,100401022201110,101100001110030,102210011101110,112100302012023,100102410403204,110042021100041], + 200422320010040: [100000210410212,100202021212012,102000032003002,104003410010031,103020201401104,110020030011011,100100000012334], + 213123000110000: [103010010104000,102330030243120,102100100210033,100002200014412,102140142001210,100141004030100,104130442103041,110000012124020,100022201040213,110221320111003], + 1002203431222130: [103241000112010,100034114100102,110330002104200,114000000030300,114101012201420,101114420310142,102112100210100,110011111104432,101300000340401,100011301210241], + 140000130120401: [101000211032200,104100001242022,101210000300320,102120022000224,100204000410301,111213130001022,101030120340201,102121444003011,102240121302011,100401400022202], + 1020020030010202: [102202204040010,103333040110114,101022200343023,102000000221222,102011014001111,102331201001140,102101001342004,102103001414002,102022011101012,103222024031400], + 1000120402321010: [101010400300001,110002211302010,100040004310211,111101144403004], + 1111020032213240: [100404210032112,100121010022020,112100322040040,100112134030041,102000000224001,102013314023030,102103111403000,102004044000100,110030121201003,102110030210103], + 204240141002041: [101022000322012,110123000122000,110212010000000,100200020144110,100230421212431,100101201021044,112400000200011,102112400224210,100400230020212,110440401003310], + 111403302134022: [102001144013040,100012111020031,112203400410130,100302320420012,102000404001103,100022211040222,112012220214324,110030400140000,102242022004100,103043001412001], + 1004010321040430: [100104100022200,101010020320410,101120201100110,102304021004012,110120001121422,120000042021310,100100030402102,100300414022102,102100234022140,101024124000000], + 140113212104010: [110211002121001,101442031012013,103202000101303,110020232002103,114101004000301,110012311001312,100241100430000,102102400314222,111022022233042,100120020401013], + 1103120200120021: [110134044242442,100002302213022,101030020022301,110120400022300,100041044101100,104032420010121,100121104031022,103004030121000,103212210100022,110144200000122], + 120101001020342: [110210400114203,100001100104021,101101300010301,101122200300011,112210201100012,102120200221403,112001122302311,101001211004233,102303011002000,102314100240010], + 1002132023000020: [114001204020002,114230000001013,100022211001110,112000002310000,100010201030300,112420104040020,100403430013124,101002100322211,112004000230002,110220111110412], + 100000200014040: [101242011000124,100202340430142,114420242311240,110141001301302,101200200300310,114011402303024,112124000203110,101011000320010,102020004000040,102110201342301], + 1004311210021102: [100114004100001,102012030213014,102003320200411,112440114040203,100401001011010,103001204002010,100340114211043,100033001220020,101100120334014,114233002340141], + 1240000303230010: [103204424022010,110304304420001,102110402001413,102131334020220,114210024001201,1031024222000122,200003020011141,100020111230000,114102010224000,114301012300202], + 1001310301020000: [111201000013222,114004104012300,114211202324143,101203211010000,101200314040213,103302140112020,114003200023323,100012014300020,114110024000020,102213214110012], + 202000424030110: [101020000300112,100002020410020,101000001111200,102012220241003,111120214102000,102113200210140,103130020213032,101430211012120,102323204113210,102403031110014], + 120121341000001: [102041100200402,112100404000230,110400112021140,110112121002403,110122221240302,102401200230234,102241230200120,110201111200204,110400104222012,103302024010240], + 1400200011214220: [100002101021120,102102012003220,102313114114000,103030304021102,100000101001431,100104100422041,100001044241012,102030420223110,102120200201042,100200011000020], + 101332113114042: [110144240011020,110011011212100,101134030011000,112000244001222,114441114123013,103220211421421,110123230124040,114000012334102,101000014012442,131000001020102], + 1000030222202004: [110221204243141,100400220010240,102300221002020,111010204401023,100000010004124,110312300040010,103120000104021,101220200040320,102102001402012,100124221021011], + 1144441010000220: [112002204004403,103013001430040,100402021000101,101104121111112,102141032001100,100100220024041,114000000023404,103030200142241,103010040123432,102112322004011], + 240201020200121: [111133110023322,100400024103122,102000021101201,112024200220201,101001440303020,102000124010400,103002224002043,110140141201202,112012030233024,114201004001120], + 121221411100014: [100012320001320,102000331120104,100232214222204,110203111111000,112104212010101,100001104201201,102300221002020,100002101020010,112010202000202,102033024010010], + 1010044020430310: [104120011242011,114300000000002,110020002104100,102111400202120,102000301101102,111400214442024,114100124002210,111122200021102,114032234033303,112400034040002], + 1020000200222300: [110402402020010,112421302011301,101023431001040,110001210120320,110300404422030,111024100022301,110200310012010,110102110124010,100000404341421,110000022100112], + 110302143030000: [101201004044021,102422122000001,100040204202102,100200124341000,110021212130000,103230324024140,112120022010120,102113111410044,101042130310010,111202014413200], + 1031222012302021: [111304340002030,110102000401214,100100111044040,103140014002031,102024102020000,102224241110003,102001014013004,114113014000010,114022100010000,114321004030021], + 124203022000303: [103100221440010,114003344011001,100021101000000,101014201030204,101203001010111,100031201030102,114201104114111,101041001003300,100001100411302,114012444020220], + 220102220004103: [102342110212020,100024024200032,221123404200214,100021024100301,1101210010010223,102042000211301,1300004102024404,100421001000020,1300102043130042,1333020210312100], + 1113300400421010: [110021000410432,100042304102210,103202000110102,102020440220202,101010010320112,100042000000000,112000021122010,100021111043012,102122101023020,110124041140000], + 1130010120120310: [104130242103012,100002131024210,102410001402210,102000101132400,110000102100012,112023140212112,114000312301300,102120214001422,102400231404200,114200422324023], + 1000412130010144: [114042102330002,100014001041000,204020131034103,114113404003030,102310030240210,102100204001030,102200400234000,103001324012043,102110222004041,100102240020100], + 1400220101000132: [102023000220003,101004204212040,112130030422202,102202014030001,100444021001102,100020404302120,112013400220104,101022424011430,112112002014120,112321041130330], + 1000141214101410: [102101320220430,110100010000102,114020444100202,114020232302203,100111120012323,100014044200222,101001000321032,101124021110021,100023100104410,110100112141141], + 200000101104221: [104132340011314,102203304123030,114012040020310,110000212104130,110200200004002,101000040320021,114131040224332,114002210021300,103230114000201,100123020032031], + 204143214033312: [110000212101040,100014401210011,110021410020203,110411044221200,112024232302040,102423031402210,114013022304040,102021311100042,100201020140421,100004001002300], + }, +) diff --git a/profiling/mix_huge.py b/profiling/mix_huge.py new file mode 100644 index 0000000..0d21755 --- /dev/null +++ b/profiling/mix_huge.py @@ -0,0 +1,7692 @@ +config = some.Structure( + globalMap = { + 103310322020340: [100000031211103,101042000320420,100100001202021,112320301100420,110101024402203,112001202000203,112101112010031,102130400200010,100401014300441,103000401422033], + 110040120003212: [114413100031332,102101001412002,100210000032130,214000110100040,103031420121210,112114222301010,110133330100020,100001001203011,102210220202130,102200120234012], + 244402003102200: [110212012114431,100001140020000,100012101223021,110031301200114,114002020044120,100021004302202,102202200240222,114102010220042,102021301441201,104103102103201], + 122013242003223: [100014100100001,102100004130301,111120004100414,101034024000101,100021424301033,102003004003400,103340410140122,100102114100420,111012202111021,100103144302200], + 1120010021223330: [110332202020000,104120130021200,112421004012141,111100220022101,100021104201130,102224410201003,110030021010001,101300401002320,112001321113132,101110434020010], + 214100003030021: [102122000214201,100242141004122,102024240221040,110320011200230,100011114300334,102303004110022,100110201042101,110134201140010,112101044000202,100040024340013], + 1000220132200020: [102231130213210,103214010102022,102000402041014,100043324210140,100023024211011,102404021403141,100010004313001,100003201021001,100122020011232,100121031014040], + 1200041022422001: [100021300101110,103010301402112,100011401031000,100020034100101,100122214300222,103134021420204,102042210220100,100103200021130,103204214043011,103020320102002], + 1000232101122040: [110011414240022,102202310203222,100042001020203,102002320220202,100010044300003,114130210231020,103301410110110,112114324040000,102124031023100,100204104320231], + 110002000000001: [110010000111020,102011041320000,114240012324120,100022010022031,102014140200013,101240110302200,100031204311023,101232001021020,100012121040101,111243002222100], + 200211022142211: [102231130213210,103214010102022,100043324210140,102324014112020,102022004012201,100023024211011,111130210020000,102404021403141,100003201021001,100122020011232], + 114121130201204: [100040031020241,101100104000222,102324141000002,101010234004042,102041224010012,100411400030100,100002000102100,114340102322021,112033124022002,102120221120200], + 104101002123040: [100032320000112,103140011442322,100312120141341,111144020011120,112142204020032,110044031204131,114012010020012,100001420412010,100102110020102,103022000123142], + 241101103112120: [110333404433042,112240002043300,110021100132240,103104221443021,101100304000101,100202210410011,114402212310021,102411011111011,103020141414101,100113001040420], + 1004020030320422: [100022214203010,110310011234031,110123111300000,100020031041304,102120004000101,102020002000420,110100302010110,100422020030044,101220100303222,100002220411002], + 1041010100001110: [111124004101012,114103220220104,102120004001310,102430121110340,101021204000200,112141104020201,101200111020111,110001200422320,103210114021430,114223242332100], + 121103011132000: [110021104200001,110441140102024,111140124100100,110310020040401,100002024303323,110030002130201,102103320232241,110302000400221,110111001302000,110210304220000], + 1042022101004111: [110021104200001,111140124100100,110031301200114,102103320232241,110302000400221,110111001302000,110210304220000,102033124000111,111000212204213,110010324410130], + 102220010222003: [114003212210013,110302012103114,103023101400002,110010120440200,110024140022040,100002100100320,110100034200300,100401201010220,103200024021204,102100204000234], + 1442130103121040: [114413100031332,112121020204344,102211030203010,100210000032130,214000110100040,103031420121210,112114222301010,100001001203011,114214404142034,102210220202130], + 110204013021024: [110301402000211,103030201402004,110420104221220,103200004030020,100320014310021,102000110221110,110240214432004,102122141142000,103041204010000,114432234113040], + 100001440133234: [102111040210242,114110000002430,102010011412143,100424220032043,114013422300032,102021004001004,100131414303044,100201010110320,100000221030033,110101101120302], + 114002033000020: [100001121002141,102000040201003,101132131221321,100004440004031,102002011033030,110310300003402,110220022132003,101001000302103,110044112100220,100010120031210], + 112123022000131: [100304201000221,100112021020320,103010001422020,102300124023122,114221004100020,100002100124101,102304100210334,100403210010142,112003100241220,102204304000304], + 1143001230040001: [101033124003122,100313144100202,103201004024412,114014222302011,103011020110211,110203420111140,111003412201430,101411214000203,110222422042203], + 1002403200000231: [100122004300410,102140014001101,102000104012232,112400202020003,102000224000011,114122134140002,102101010202004,114400202310210,100042030201341,112233332034000], + 1003123041101031: [110043132100300,102220120203200,100002004201122,110132031134031,1320303202002000,1321200010022312,110130330012140,114102134002330,140403400240000,100003230110201], + 242220101103400: [111130112100210,102202200240222,110131044200121,100100004102234,110223332120231,100001024301322,114013044102010,114220114140122,101023021034304,110200210110130], + 121030040400021: [110011011212100,101134030011000,103220211421421,110123230124040,131000001020102,112200412033030,110420001000202,100102110402220,110412310030001,114012022302022], + 100104011300401: [110320414420310,110100100101041,100420124100211,103010211222002,101040120320230,110013021300010,101043234000412,101220000040002,100422001002123,114010010010002], + 1004003211220032: [102400100230000,101100300302102,114120420223002,100002210201212,102302020212101,112410424012010,100030004104210,103030201434002,110232110004010,103021201430000], + 223011102020040: [110012420131001,100132040031022,100020310000200,100220004030002,110020002003334,110014000442004,101441204020001,102014201411102,103231320100042,104121201242032], + 100200110422111: [103100221440010,114003344011001,100021101000000,102140000212141,101014201030204,101203001010111,102424114020143,100031201030102,101041001003300,114012444020220], + 134300111030221: [112100124023402,101020044011003,100002414210010,102010042000041,102242204040102,100021014100124,100130244302034,100122040012210,100014010104404,101020104000001], + 114001000330100: [401142101000022,400114001102410,102100000012031,431232000323104,1012100023110102,232023302143031,120200122422404,1040100003200241,111414004440203,1020220210340010], + 211222012120321: [112000112000031,100121214300000,102123214020000,102022124012030,114002320022312], + 1122000200402140: [102401141113031,103042420143020,102304314110202,110210400002012,113032012204012,112310002020302,100204311000400,100403012200201,112002111121013,114211100001224], + 332000024200013: [102120010220042,110103312142034,102210210312302,101120100320100,114140014100000,102110004002301,100130020001030,112022100213011,100101231202322,111210020001013], + 120041442412123: [102133011413110,111001200041102,101223020300040,102034324000220,100210000032400,101230020303000,111340130010314,110200422121211,110214220002020,112220414010040], + 1011011320300100: [100102024301030,100111134302041,100112234000041,110004244214343,101002101020003,102214021120301,114221224100022,101330210310300,112003021111000,102012141134211], + 220020021000101: [100301001000202,104101112102403,100023121223031,114201432320014,120000002023011,102133120200123,101014020301201,102000031130401,101010111002141,114123124143310], + 1024011342000021: [102001001130100,111204203012002,124020002020003,122222120003214,133332002141010,144000013213001,124010030100142,112310202021010,110014020020011,100140044020011], + 1131011002310011: [102230040200031,110122001010214,114043140010022,102101204000010,110022300420031,100100401040001,114230230000123,100222024320003,103323001400013,114013012300240], + 1142024120224002: [102203344011410,100021324100000,102103430210003,100012014300120,102414014022212,102012220241003,101004411032102,101430211012120,100204021000012,103242044020102], + 1100004410231120: [110013202003320,101031241000010,102120231343224,110030332100203,100314114322101,114404232310120,103100034001310,114002202210331,100031301020100,110111032140220], + 1440220030001122: [114010330030011,103021220104200,101010020320000,112000210211020,100010324210003,101000000343443,110002400011111,100402132200000,111100300024000,103144040104204], + 121414301110004: [110144240011020,110413401240204,112000244001222,114441114123013,103220211421421,114000012334102,101000014012442,100312401002102,111022210021013,103110001420121], + 130004004220120: [111240340004003,102021024000010,111101222244030,112011012004300,102300010242330,102000401120420,102004012043122,114011102210402,100120001014040,114300100000041], + 1013303000401020: [101000024004442,100002100000100,110130030020000], + 220041302111231: [100002014200331,100034244210020,102012004000003,100411000030110,102041201121230,103011014042120,100000030120242,102110400210023,101012204221200,111212422222300], + 1000031031200013: [101302134233230,100000130010033,101030404212000,114102224000201,100022021041122,100020001042002,100013011020311,100120041020012,102012204000242,114143024003322], + 1000303301100221: [111333104124202,101000304014100,100040011023101,110301030010140,104100002101431,101123232010002,114421242204443,110100222001100,103102000121300,110010331230210], + 1410211342331412: [111002100000102,114021010040140,114222302321101,102101024002121,110014024202014,110220130100010,100020011030330,102404221402210,110203022032320,101222014230110], + 1411020122202044: [100141401021003,102010000231120,101000400320211,101001010300214,103010020142023,110132002212113,110010100040100,102101002002002,111020302232033,110224030114311], + 101010042001102: [101221020040220,100103104302044,101041030320401,102141212000200,101203121020430,102020004000014,100000211023014,114144014122041,100201111002224,101410304041000], + 204204011102020: [100212030414010,101400004022210,102031021441200,101200020303202,102301324112020,111340300010010,102013224003020,103013020123142,102240344041020,102140202001100], + 240000420312002: [110002004410202,102103114000024,102240221000001,112041002002124,114000024101102,140343100002103,400200234320200,100020124204330,100001424102041,100100021040230], + 1030000001422430: [102343230224321,103211200100400,102112231020231,100022004300020,102320000240102,100042144200000,102030304001101,100020420121003,103020004011414,100001104301200], + 1104234221030010: [110000322130121,101023001002020,111300222202234,100200001210021,103204230111030,104130020011020,101114422122000,102001314013400,114110414140400,111201100011141], + 121341130003000: [111102004100101,102021100220101,114000040010421,112042110220004,100000214240410,100433201004014,102301102004413,102003000220111,102010100204023,102414040230400], + 100101220022002: [100010024102110,101041200320012,114303400002201,110204211000331,112121014003422,114430102311021,100240444100022,103004411424400,111014002140322], + 1023303420422001: [100043104240004,110002034200042,100001240100033,114100304002030,102100001340122,112030010234104,103414101212410,100123021223100,112302011102312,101020030343002], + 101114102124321: [110403244220202,103113014002100,110120400402324,100402340010310,112010020211000,100102200000211,103030201240100,102300210210222,114100332340213,111031030024010], + 1422302020100030: [114020000030002,114031000022030,100201211003004,102014002000401,103103241421322,114121012340044,102000400240203,102104304023201,103310300140324,100002224244002], + 1121202400231120: [101211201202134,103120104030100,100004000100101,102020030220200,110031404423144,110003434410403,111110000014401,100000204312321,101004000304012,110300121220201], + 1042001221000013: [114032104100141,101213114040141,102210101002412,111140100011101,110122421241103,112001144002010,101013030304101,100012011022000,102000004000013,102021241324040], + 1102433033042110: [110104112010103,111102004100101,100122004300410,102202414041044,102140014001101,102000104012232,102021100220101,114443330001442,100230120001003,114000040010421], + 100103201011144: [110102401201204,102400100230000,100212030414010,101200020303202,114120420223002,102013224003020,100002210201212,103013020123142,102302020212101,114303340000001], + 240343043023011: [110120144200000,114022412330004,101200221022044,110241112020204,100002004104004,102100224000210,102310140240012,100014204201000,102103321411004,100400001001300], + 1020301032424304: [101302134233230,100000130010033,101030404212000,114102224000201,100431000032001,100020001042002,100013011020311,102103331400000,100120041020012,100020001041231], + 114200022220040: [100014100100001,102100004130301,111120004100414,101034024000101,101243024011000,103340410140122,100010021221221,111012202111021,100103144302200,101414100300221], + 142041243300010: [102102002002242,101130104022002,101230331020012,100004244210201,102420124024204,122312222240401,102041014011340,110200130004300,100140101012000,101400000302141], + 1002203102111022: [100434000032200,110004020020022,114032412303041,112000301122111,102020130212402,100010001020000,200000020021022,114321212322303,112302112002211,114202002333330], + 1110102121041413: [101012310301211,103112200123144,114242304004011,102302200241241,110001420021023,110201040003402,112301421130130,110020012100302,114412202320010,110021030030202], + 114020200220012: [102010114022011,103340041403223,114002200000421,101020321002002,114302210010001,114030004104220,100104004301000,102443211401140,102301041000014,100001111201214], + 202011212123200: [102203301123001,103210400110122,101112020300011,114104302341000,100400201010000,102244400201444,101010001000121,102304000220032,102002131132000,100000031024222], + 201032103003132: [110212041114210,113210300100002,112404024011000,102131034000220,111212124130140,101002014013010,103402020120010,112110100230023,112003044002004,103020200102200], + 120222032001012: [110121100004131,111400214442024,111122200021102,101041100300001,102140011440001,101011220342010,110200004221020,103114211441300,110000222010004,100114000101041], + 1100013040001020: [100003031030034,101001044211204,102100010233022,102120400212001,114313022302101,103001324000110,100002014200021,102300401001010,103212320212011,111120034400000], + 1001031021300022: [102000020220000,101020104000040,114412142320040,100003044100101,114012402332300,102220211122102,101010110302010,100032121020101,100013224313301,100012244240030], + 124000010122242: [100032320000112,103140011442322,100312120141341,111144020011120,112142204020032,110044031204131,114012010020012,100001420412010,100102110020102,102002204001140], + 1121211020204132: [110020301320101,102014001130210,110401041140300,110002302201420,102202001120002,110200010003201,102421004041011,102240040202421,101001110300111,100130004300103], + 121320202004301: [111014240041102,101100004200110,112021221130424,112200041103002,110400040402041,112001011112202,100112004304314,100232041001122,100223030001010,100104231000300], + 1024242230240244: [110322104424202,101202421002031,102102220312102,103004204021310,112220102043102,110012310020200,102030130241300,103030120100220,100232224340041,112400002011010], + 1002100010130110: [101400001011042,100002011020211,100100110010010,111110002213142,100002131030310,111102214100400,103220201402330,102321000221140,103113124030200,102110300311400], + 200010402222410: [101210320301302,102100221340112,100114104101001,114002244103320,101023221000031,101400014040400,102012034000402,114221004002212,102100122002001,101000011021414], + 112300020202111: [103141411420221,122102400312000,110002100110002,1340024302404122,100002001043010,113110330121030,410020013004430,1002300040412102,1210020204140003,123211320000102], + 100102203210034: [102023021100022,111200302222011,112040241120204,111000022200000,100010011232324,110220030000133,110000330430311,101211221014003,103111230120100,102221220200021], + 1021001032000012: [102020010203200,100011144312020,102011204001010,102001410221023,110130201302200,103041021430301,101100440320434,114000402211404,101000100302003,110000030430422], + 1031102424140120: [100011010414200,111121102240240,102002121101110,102403100202003,110000100041101,100400000010033,100101211001320,101141020321000,103224101400400,102000002043020], + 102001021434201: [110131122012210,114010200040441,110032014420232,100000344100100,111304022202211,102302011002003,102011021121200,100012441030002,110222042022111,103131004002200], + 220100132400104: [1010400230221020,111320012221132,102302144110440,114140004123122,102143202000400,111020002202333,101321311004010,102110241342210,114122302311011,100002320411400], + 1110121023020002: [100022041001002,111240340004003,111101222244030,114032424122040,112011012004300,101021401003220,100301020420101,102002202000000,100022024100041,102010410213111], + 1042030001044121: [101230040301234,110033032100000,102303014024221,100100224304110,100400432200321,100020200012311,114140144122230,101400201102014,100000020004004,101040040303102], + 1100100224104011: [111130112100210,102202200240222,110131044200121,100100004102234,101023014004000,110223332120231,100001024301322,114013044102010,114220114140122,110200210110130], + 212002042300000: [100030220100110,110011202100142,112400102013231,114012002212100,100002114314022,114203110001031,112030122000211,111004012200210,100413131013301,110001102103432], + 221001240043040: [100420021010013,112101302302202,102212011120200,102344111104233,100432104320110,114021014020000,102121321340000,114200214002024,100111221011100,100023104101340], + 1040021200420124: [100042111220111,112220100202000,100042041220010,100403211010100,103240301400123,114102210214041,100021300103041,101010204000242,111334004121414,114101000213410], + 1101110030041022: [112013300240132,114303044030300,102340044111034,100110021021010,120003030010112,114200212320001,101020240313001,102330220242002,121400042034110,100033201030040], + 1030000302042203: [102110231441040,100113214302002,110000002133140,101233341022410,103021000144000,100100124100031,100040204240000,114100012313002,114440440000034,120240000020201], + 1403121230220020: [110200400000020,100324140141402,100002204340200,110000410001034,111140000000000,103102224034002,110022002120332,111110230014001,110020041310021,110001001200323], + 203110414022010: [111240220002100,110030344201413,101001014001021,100103224301304,114000100020200,102102100231000,114040202330200,100410331002222,100032204311200,102202111110404], + 133032004200001: [110314100012011,111020422203010,103121124002320,102240300202212,114140422203401,110210420000001,102210331401030,101102104000100,102031010200122,111104202112001], + 1120000102422014: [102140211342044,110020301220411,110100200004404,110131142010001,101032441003040,112004400210201,110004102230402,112021004020000,101012004001204,110420001344420], + 1000030222010034: [100320031001240,102104320220212,102100200232044,102434104021201,102300004022020,103003301240122,100210024101140,112220011101022,101000130304001,103020024043010], + 300210002300114: [112100021100243,101123001100112,112003002001002,111000200012220,102120100230203,100111124101112,112001010233001,103313021401232,110430034224001,114110200221240], + 1421020010140012: [110010002014100,112030001120220,114231034004040,100100301202103,110301021331320,112001100232420,114020244023001,110342014420100,110200402220240,100114200402104], + 300310000040102: [110301222101110,102023301102400,102012204010044,104120110010402,111010214402000,110401440001204,110204310112224,110303104423010,110340022023321,114010200012200], + 101010002031100: [110324020012330,100001134302201,102100011402012,100020221031000,102032220220223,114042004020130,114030400021223,102022021100102,103301304031211,102000004013440], + 1032221241200404: [104120011242011,110020002104100,102000301101102,111122200021102,114032234033303,100000020201032,112011204004112,100003000002034,110102022000200,102200034040443], + 1131211404001020: [110200100002031,101420310301020,100020330100100,1002443410030003,111103224103001,100011231042030,102100141413100,102110021342213,112002310211210,100010031020102], + 132013120010104: [111300232202103,102301401002404,110122120100022,102012004010000,102400100220000,102001104012021,100242444300104,102002104014323,100401241010122,100010010102122], + 130000310202012: [114200044114004,102202010204130,100220101204311,100002000102100,102100430233212,103003210141014,110421222011222,100201000410010,112110202014400,100400030013200], + 1111023010042112: [100000201220420,114000030021040,101002011020001,113141112413242,102021111130104,110401030101001,102201214011331,100013011043231,102031114002042,112302012020342], + 121010001111310: [101400220300033,100012021032040,102001130224032,100012021040320,102130224023220,102100401143124,100010001030140,102110101410144,114142204121324,112102421102022], + 1113001011001223: [110202400003213,114112014140000,110001012101334,114200124000134,100001114302424,101222134011002,100003011231420,103230231200010,100431031014023,100120120401041], + 142034000000112: [100310304310342,100010041031020,100042400001023,112402000200101,100020201221000,101010020301243,102030001103000,100040021031201,111010130022401,112140214000020], + 1012401424032042: [102401121113302,111201210000103,100101101010100,101320040302031,114010102300010,102321044112101,102000014002000,101034014011332,101203011023020,100021231020200], + 1103400010414230: [102010114022011,103340041403223,114302210010001,114030004104220,102443211401140,100000221020014,102003224000022,100010031222001,103001114001210,100001111201214], + 1400000301203010: [114122134140002,103012011434022,101032010342004,102322330243202,103101411424112,100100114103001,102134131144121,114030222300123,102102301021403,114103402201140], + 214024214401412: [102220242000201,103010021410203,101000304214111,102120040200200,103202220100114,111100132103413,112203220204012,100113040003021,100010204200010,102410134022300], + 1221011020200210: [110041030411301,110001041213031,101110044200100,102411000200000,110414300030001,100030020011022,114100122342002,111202012222402,110033041200104,102000221442214], + 1000120020110040: [110200411140130,110114120120100,103124210100201,111014200024034,102301002004242,112020014000340,110021404214210,101003014210212,100130220400031,100210024300001], + 201001342101001: [102001444000222,101400134043222,100010400013202,114340312301134,114310242320310,102110021401100,100113201011032,102230000204000,103102044031002,100011421002120], + 1000000133120020: [110230000000002,110220301202400,101003140322000,110401001002400,110210024220020,114201142324042,100401424300314,102213401111223,100040120000031,102002104011244], + 101400102142302: [100004211221210,110201001212001,110200134240420,110403221000002,101201304200320,114022042302201,112002320212232,100002210413202,103140021401211,102404042001400], + 100203202010202: [101000114000402,100043100123004,102014014000100,112212042024100,112410322024122,102300110221100,110002332102000,112001111111212,100020104300430,112041020221402], + 1011401013024410: [114444244144110,114201004110120,114033234032101,100412114304000,103001020120202,101004411032102,101000020302400,102021014012210,102244221114031,112400000200011], + 131012202321232: [110041030411301,110001041213031,103301210142043,100002024200142,101110044200100,102411000200000,110414300030001,100030020011022,100400014321101,114100122342002], + 100303010210441: [102304034110400,100043010120010,102101124001310,110030110122402,102430300201034,100004121030301,102143432000102,101031001004201,114001110033210,110120011014412], + 1111011030001020: [100032041021210,110001041213031,101110044200100,110414300030001,100030020011022,111202012222402,102000221442214,102040041320010,102402104022000,103203401400132], + 1420144022031000: [101240220300022,102200130202201,100002010014040,100022000410041,103020000102011,103001031420203,102301324112020,101040421033204,103130011441212,102240344041020], + 104012440012200: [103000001432331,110131110401120,103000004011102,100120041014034,112111110422120,102130300200301,100121100002240,110224032100120,101104220322100,100001001201301], + 120311002000121: [101220014012231,100104024303320,114422004110130,112210132031001,102010310213001,103244320114100,103422430124013,100121424231222], + 1002120002022122: [101201220300012,101232104042101,101220404012304,101000304000400,102020204010341,112020100202034,100140410020232,101221004040204,100412414304143,102110404001401], + 1040331220001000: [102041310200042,110301030010140,104100002101431,110221000111302,101010001002000,110022140120012,111330020002213,102011440201423,114011212320331,100002204310140], + 142030323441430: [110020120023302,100043120003103,110002000410040,100433001014104,100000004102121,101022411030002,102000021442024,100030314100004,100404130020000,110400302114103], + 1020000001100400: [110001202000032,100024204211200,114200004110244,114230412332011,101210101010023,114422114140221,100001211042341,114032104123010,114303122321110,114330204034200], + 1001130242231402: [100042320001030,110024001010110,100100014300230,102043104010014,100001004300242,111120044100110,102200201110443,114240314000100,101002411030000,102002324011002], + 1014202010302102: [114200212322001,100401210020002,112210322040121,100402042200000,100010111022102,102000224000000,100002104302110,101022440300020,101402010301000,100000220111021], + 144100013100013: [114020200020222,114330002323002,110213022100021,102202000240014,114424424144210,101224321014333,102100121342000,102204321003224,111222002224302,114100104030132], + 101213002101214: [114014104033302,102120200221403,110323110104120,102110314001121,101020104000300,114003402300102,111202104100014,112402102021111,103344224020241,101002114000424], + 1012442110402240: [104310001300102,114021132202032,112012004004324,103001314001021,114122220031004,103040024041111,101004004213014,111124002211203,112034420220403,101211231023001], + 1002210200000101: [101232314010241,100301300121100,110042400130000,103020124010320,100021300101201,110230022122031,101000444214021,112102112301130,100414004300100,112102232300222], + 102400210400022: [110010334200041,100001024102001,321114010100340,102322101000200,102110100322014,110413131000201,100000100000432,101020021114310,114200104110001,100010314202003], + 1043003020000104: [114101024120020,102004011440212,100000001021013,100011204300012,100101234330123,110024000432310,102012101443110,110032220022103,102102104000102,101210031201114], + 1243002022101103: [110203120112002,110000002100100,102221410200012,110213401202110,102300104113403,102213224110010,102300004112300,102420024020120,100040020001022,102141140210200], + 1421204200010112: [100140101044224,101120004023340,103040031403031,101030014001004,102012421412000,100010044300131,111010130002222,110200300000010,110144102001321,100020304102100], + 1003013101233010: [102400111402142,100040240004024,100010000002400,141030301403400,100000024100211,103224200113121,110140101300004,120020211120020,110230010010142,101002041000124], + 101432210141203: [100310120141002,102324014112020,100301421002002,102404021403141,103022021431010,103200020111014,100010004313001,103104200210410,100002200410030,100121031014040], + 1104003002031130: [102420020200202,1023413000203201], + 112011130023123: [101020014011102], + 1102310021242142: [100022041001002,111240340004003,102021024000010,111101222244030,114032424122040,112011012004300,101021401003220,102000401120420,102010410213111,102004012043122], + 1002120410241114: [100222000144103,101240000310400,114022002211402,102311020240221,110211000004002,114101402200030,100000034200300,100010124300001,114200022322000,103133001441320], + 1022312211002000: [102123140310122,110101214402023,110400014224001,101410030330122,111000144410222,100040001022000,100222404342030,112204022020043,112320100202120,110222241300101], + 1402011002013421: [101043042401310,104001222102120,111412020003222,101113012101010,111212022200012,110023132100402,102022102010211,110231202040203,112112410232001,100021220002020], + 1010121032032211: [100002024340032,110000011220401,102112340210300,114100214000010,100000104201200,103000304010211,100010000002132,114100042311312,101000014001020,103014141222013], + 1020030002101022: [102040431121110,100400002201113,114111100021420,112024212301420,100300310140241,100240134323001,102111024000402,102001011100100,114402104142102,103312241402001], + 1010240311230422: [110200400000020,110203131211112,102301004110004,110021100023210,110402420402001,103122000100403,110000112100402,100002204340200,114103412201420,111140000000000], + 1401004204000003: [102102011412000,114204030210041,110033101044200,114440120000030,101002004014401,100400224323100,102112112004300,102010014001001,102000001440004,110321100402021], + 244331203200002: [101221422120021,100001000002210,100400320033201,100004130002301,101210300302302,102020131413423,110020204200342,100000220011133,102144012001113,114431110001011], + 1130301120301001: [100401140034220,114002002300222,101242004043300,101013111000000,102102131340404,102420041111041,112004312310301,100040121030000,102000404003020,103111020223101], + 1002000403000204: [103343014022202,102003104011000,102220330202001,100022200120040,103002020110334,101021134012211,102140200310400,110010002103002,100220034341000,110200002121242], + 221400100111330: [102031100200300,114102134122020,110024102010002,103010034004303,102023032000000,102101440201242,103000204003200,100021044343014,111433000002144,110001002002424], + 112133300441020: [110120101220000,101040014002010,112001001133213,102000144014000,124204212002003,102311101002242,102110210210004,100000100412410,100012441220104,111032320020122], + 133313202104310: [110013334202122,103330104030103,111200002220003,112043421121002,102212030201100,100111401011110,102010341440030,100001120100002,114001000024011,101021024012041], + 100143040212102: [100422314300200,101210241204043,100123011004113,100420001002101,101134224001001,101021204000200,102321234111310,101200111020111,102000024000002,111122222240232], + 1432344120130401: [101001040340004,101013004002011,112022334022101,101011324004222,101410401010030,103210241422022,103240001403000,102202204040220,102121010212140,110020124200230], + 1100030203241342: [100440104303400,102122000214201,102220241100202,102024240221040,110320011200230,100342024100204,101422034042201,100011114300334,102300001002140,110040122000002], + 1011102003042024: [104110021244203,102224101113104,102103022002001,102102224000012,102100102001032,100142431013000,101000031001011,101100001102230,101010130321200,114004322330012], + 300210041431432: [103114001441122,100422004320024,114211110023303,111000302230100,114044144020400,103001101422012,4000113102314022,100022204104123,1400100000042343,1002411322210040], + 241241343121111: [102021001132040,100032201024101,102301004110004,110402420402001,110000112100402,110021021210300,110404000000012,102000101120123,110221022101104,110023100402320], + 1100142404020120: [101210144014403,102111420233012,110000020022324,100020231201012,102210424042300,110220032120121,102130240221020,100101101020002,114442102312001,100030201024402], + 110001043032202: [114240012324120,101022011003022,101240101000020,100003101003001,102313100240202,102000014002101,102110422004402,102100411340400,101300414221100,114020210020424], + 1100103200140000: [110013202003320,101031241000010,102120231343224,110030332100203,114404232310120,103100034001310,114002202210331,100031301020100,110111032140220,100020010200022], + 212420003003124: [103000001432331,110131110401120,112111110422120,100121100002240,110011010001020,100001004340202,100220100432201,101000140200002,110140001201040,110001041310202], + 1041144140041401: [111120214100003,100014131222022,103110114004210,113002020130400,112012112001000,102101404000324,101142141144040,100101231202210,100003001223010,103142204001221], + 201023043021424: [103001024002110,100231114320100,100001000002210,101210300302302,110100012120201,102020131413423,110020204200342,100000220011133,114013012240011,100010104312120], + 1011412300010442: [110104112010103,111102004100101,102202414041044,102000104012232,102021100220101,114443330001442,100230120001003,112042110220004,112203221102231,114022400020320], + 1130200034001002: [112010102000041,103210304032003,102130224131022,100000201034001,110400011140402,112011220222001,111230204100010,110023022130322,110022222231002,103110100210212], + 101001320111143: [114000044020204,102320000221020,110142020400012,103131420221204,102120141343312,114321114032200,100142011022211,114230344103210,100030020104423,100102011010000], + 241102301203043: [111000010041300,112000002003301,100200221000243,102400044023410,110423034242000,100104100412020,101020031030240,111204000003031,100012004110024,102142000210040], + 100021101400201: [110000101304203,104121412100011,110040020001022,101104020300301,102101004000011,101401001010021,101200200300020,102011200213421,102011021411140,100000001020100], + 1041203303120002: [110010334200041,100001024102001,102110100322014,110413131000201,110020104210120,101020021114310,114203002330010,114200104110001,100010314202003,101013220301033], + 122400010411021: [103100221440010,114003344011001,100021101000000,101014201030204,101203001010111,100031201030102,101041001003300,114012444020220,101414214021020,114412010002302], + 1143000322124010: [110041042000232,101002400343001,100032400410212,101202321024330,102303000241003,101000001002320,101310201000040,102004341420021,100012101001312,102010334000140], + 1040230013042024: [102302440220001,100104400403240,100020111221020,110010122102321,110002322101200,102220124000003,101020201003002,100230300001042,100311334020020,112400022020023], + 222004201002140: [110313002103302,112424204040112,101000014000004,101142310014123,101430401010120,110102410400023,102120220310102,101010200311020,111211214133000,110304102022001], + 1042000233033310: [101000004000241,100120000410020,102311000240202], + 1000002141204230: [111240220002100,110030344201413,101001014001021,100103224301304,114000100020200,102102100231000,114040202330200,100410331002222,100032204311200,102202111110404], + 134224341021441: [101210320301302,100440024301100,100114104101001,101023221000031,101400014040400,102012034000402,103341124011404,102100122002001,101000011021414,114101000221221], + 212200220320113: [114423002314000,114040002210432,100010040122204,103314044033003,114102224104002,102001420220112,114422404110312,102403144000120,101033041032041,101010010300020], + 110100002004320: [101000040320021,114002210021300,101401300300011,100032001041230,100141120014242,113000201000000,100142114304120,103031014003010,101001021032110,114400404121002], + 1411200112202131: [110030002000422,103100014031411,110000300424304,100032121024110,100011004343022,110401140004202,110040002034100,102402330230011,102022400211311,110203210002230], + 330234311421104: [110443010102111,111320004131241,102020101324002,102401030202031,100210031004220,114140304122040,111321012222400,102000104002003,101223000300000,114201100210120], + 210040200410202: [110010000111020,100430014323000,102011041320000,112100021100243,101240110302200,100012121040101,111243002222100,100020411020310,102121401402131,114030012302003], + 100000040042044: [110101210013000,100404121014002,101240220300022,110120020002304,100011000202214,100000024100000,110212214400114,110012101102100,102102304001200,100010040001210], + 1224441200202014: [111320012221132,102302144110440,102143202000400,111020002202333,101321311004010,102110241342210,100002320411400,114201000004122,100143034304100,114021002331014], + 140222000310233: [104111102100000,102012201321104,101021004000000,110130042014110,103012301401041,100022130100210,100001020002400,103042224001110,111000230041031,112204300204013], + 130101221040100: [110410412110241,100130124030404,101021121112112,110101002012003,111131132101000,102300131102042,111121230030002], + 1033022310023442: [104120001244220,102202300114223,102310000240000,110301034241300,120440001302100,122032310023401,110113002140210,114331204032013,112042402000000,100002010000241], + 100204342220311: [100010014100021,110403241001010,100101334233020,103120110111300,103202420103102,103004330103000,102002424001223], + 100044003200110: [100021400101221,102241341113010,102300020241001,114100124100413,104130301242304,101001114012114,101141400302200,100002044101122,103342424024214,100100021040420], + 1002131022022212: [110200400000020,100324140141402,100002204340200,110000410001034,111140000000000,110022002120332,111110230014001,100210200034304,102032020214001,100301101000021], + 122003200104101: [110033000022043,110100200030100,104412212102010,101230004040022,100000411231000,103140021211010,110132020031210,100020140121034,102340211000200,102300231000210], + 112200012414342: [140400400201014,110001212100204,103220130211414,120020020010400,101100211042114,121022000104032,112101102012030,111201122241213,142100040004101,100002244100310], + 1014202212322031: [100021000104004,100002200022012,111140204103210,140004010302423,114200320003120,100200113201000,141220400002200,100044231103400,100411033204412,110000001210210], + 130211322041021: [110311022103222,110302002100013,100210240412200,100000104343000,101140211100200,112301000204230,112202101100120,100000110412000,100034010000110,110402404222022], + 132200002220122: [102100441341013,101440004042202,114201102342110,100100204101010,114101200210030,100104004100400,102002331440012,101223301020130,112100002302240,101430001014014], + 110230202100302: [102012001130022,110040322000012,100331124310011,114102222344020,101042020300000,101220201204012,110042104411102,102142101121010,103200211200414,102111111121420], + 1100244431221122: [100032000002120,102313234112000,102000000220040,111101100020030,102014024011240,112022330222011,100030201220012,100203401002120,100404024103100,103144000112000], + 112120203210001: [101241200300411,110111001300001,110200012120122,114000102330022,114021104100400,110000430001014,101214400301420,112420200202001,110122201304044,112000004001011], + 1010021212012040: [110101114200020,102144201343034,112132120202010,110002201320001,100430010431044,111020122230001,103040201222041,110111221000100,102341131103201,102100204000340], + 1101003002401011: [100000041032002,141000211410012,110101322000312,103002420100102,114000204013024,110101221001401,111044114411101,103423300120104,110412140000033,103021100002140], + 302220212000441: [110023342101220,101001421031220,100021004310222,112220322030220,110202222043022,110313312021120,102223400201104,100220214333200,110330234422000,111000034110311], + 120200310232204: [112000210212000,100112001014144,103310140140002,101310340314200,142012003022120,111130114102040,100111100000100,102322104114020,100010131001221,100013201220121], + 1020004042003403: [100110400404220,114221032331220,103200104032220,100212031002000,112002004002011,103100024001400,112400014020404,102000020201240,101012004044003,102021010212032], + 1114040203024320: [110020120040121,110000100022040,111021030042411,114004142244000,110131011000142,102401010202301,110202012020000,114240000001020,111110004101041,114132022312030], + 1141211203210210: [110301301232014,121202234011000,102140002000000,102124021023300,112444304040204,122022100000222,100003024211200,102102402003021,114302402321024,110202020004003], + 132004224340023: [102002120203400,102000221101002,102000431130020,103120004004010,102143000210010,111104404100200,114432224142000,100202234320210,102330124110411,102112400210210], + 124200241310040: [110001121012020,114244444114012,110404002114232,110032330032030,110032230140020,112224000203234,100404112201001,114141112324244,100111040404120,113431040101200], + 130014011300003: [110310044430300,101010021020013,110200020001000,100420104100222,100401022201011,100030111042110,110032110010141,103302000142020,102010321104413,100102210402003], + 134414300403411: [100002021021021,102200000200300,100000101040020,100110040013320,114023012303230,102402000202120,112442220201020,110002100012000,103211400100200,102132300233002], + 140221020202033: [100003104342121,100400414321103,102132204131302,110020034203040,100032304202003,101420300301103,101010231112144,111000100003022,100113020400211,100022030414220], + 1002220010000302: [103112010213010,112200410200142,101212000301013,111400002102112,100034100124302,1320102201231021,100000211020034,100000040413022,101000000323000,100011221224211], + 103201211120304: [110441234224400,110030002000422,103100014031411,110000300424304,100032121024110,100011004343022,110013122130200,110401140004202,114020204102020,102402330230011], + 1000304403212210: [103122020213112,114101100211240,114122134140002,103012011434022,101032010342004,114102102344110,114010002300003,100112110020301,100000004102124,100022301000112], + 1001320110010041: [110011011212100,110123230124040,131000001020102,110420001000202,110412310030001,114012022302022,101042024210020,102202144030004,102141111100102,111030340040341], + 1002002040323201: [102100224000210,102400100230000,102114022004023,102031001411010,102030000223420,102031021441200,102300031004340,100213310112333,101200020303202,102013224003020], + 1022232012234013: [101011010320431,103041414001042,102441324022342,100002004344013,103220000104122,101401030302440,102040124010141,102314221101100,114240004002100,103131401421331], + 1040202023040201: [104132340011314,102203304123030,114012040020310,103132004002242,110000212104130,110200200004002,114131040224332,100123020032031,121002023311103,100021124203441], + 1002440332021113: [102004010220020,111000010041300,112000002003301,100200221000243,102400044023410,110423034242000,111204000003031,100012004110024,102142000210040,102320214110001], + 111301001000030: [110204004430204,110300011230013,102100400222242,102122114003140,100002021032001,102011404010000,100000011220004,114111002340233,110000210004001,102100324001200], + 232110121020324: [110020301220324,100041000010302,102020100243032,100031001020040,100104001041200,102012200202303,101110404021211,103110041442122,114210400000112,114042014102321], + 210031213113040: [103242420100012,101400004022112,100100210000011,103002221400000,102022030241032,102200000200201,110020402004210,103110020210000,102120124004021,100022141030334], + 1040100401210131: [102420101111121,102101244022242,103222000100010,102013131134030,102004004010011,114101042313041,121211001014412,111012222200402,103300221402010,114021004010042], + 1000130012301000: [102021001132040,102301004110004,110402420402001,110000112100402,110021021210300,110404000000012,102000101120123,110221022101104,110023100402320,100020311220412], + 210104220300403: [100023114341301,111000020010011,110101302141002,110114102004120,103212121402022,103330410111310,110201001200101,100102014001304,102030120200010,101030441032022], + 222012013140120: [110004202003210,100424220032043,102021004001004,100000221030033,110210402031211,112032220240044,111220100010101,101012400340400,100020330410000,112043101112100], + 1011000044400003: [110413304221020,100440000030040,112130010202041,102012404000211,102141010230441,100100341010111,100110214103200,101030320322101,102322121000140,114140002313010], + 1003200020100003: [100442024301200,411231400122100,100400414321103,101024000322432,110302030412400,100110020000040,102132204131302,100010100000320,110020034203040,102014031440442], + 1204020342100023: [110001332120300,110003000420200,110243234240200,110004014411012,114110200212210,112000120232022,102041220200010,100002320113100,112240200202201,110020321120011], + 1221300430001000: [100032041021210,110004301222000,102040011121100,114310000001232,111202012222402,111322234130000,102040041320010,103203401400132,110104002010100,100030024303023], + 114320100101321: [100031300002022,110210020002243,110210022120040,103002044002032,100101020402424,102201112000001,112211120202000,114211040011201,100020100423404,110001222202031], + 112000242020101: [102304341100321,110010202103141,112003234002022], + 1011020202100000: [111443032100000,100010314103002,100240240430022,110310321232001,103221100112240,112000000211220,114022300002101,102323131000021,102020304012021,101020024210020], + 140022010210210: [112300421134001,110321031234422,103021004014220,102023001440404,101023014004000,100020010101201,102312344020020,103210404010101,110124411120222,110100242012000], + 1420302200420011: [102041100200402,112100404000230,110400112021140,110112121002403,110122221240302,102401200230234,102241230200120,110201111200204,110400104222012,110104004202014], + 104210020310230: [101004010304203,114104204002313,114300000002130,131204100021112,121200013012000,102122210230200,103110411212041,110421410100301,110244400212004,113003221014312], + 1011022012144233: [110241142024233,110021104200001,110441140102024,110310020040401,100413311002132,100002024303323,110210301200101,102033124000111,110400241240242,102210101121104], + 1114132034120400: [100441204302021,102100101340232,100011320001003,100000221020200,100200000030010,100200010431000,100003421040000,101012400320022,101332004231001,103300004030100], + 1100123300430003: [102002040220110,102141220210212,111320022200100,102232004040004,111202024134001,100000014100202,111302120011012,102203001120342,101012104001020,103101031440430], + 111031040332200: [100040031020241,101100104000222,102324141000002,101010234004042,102041224010012,114340102322021,110311011330111,103040044010112,102310001100113,102000114010020], + 312000003010222: [100030324200410,102110202001010,100040041020102,114200020003431,114041002212302,101002200343110,103332044032320,100212024322044,100140004102001,114101024122320], + 1201001101040412: [102101004000411,114221312340014,102434121112224,101200210300413,100311204312442,101211204201231,103210021401223,111110014101210,100323140143012,111130412210000], + 120444122021322: [111030212113431,103222004032000,102233034000002,110123011200000,112130004021000,100100200021431,112101202012010,114240004000000,101100304021321,111212024101031], + 1140403033012140: [101214104041040,110104231221040,102012204010044,103101000100022,100020141044111,114200000002420,110401440001204,110204310112224,100042110122000,101021021002110], + 1400100200041100: [100131031020002,102031401100332,100014201021012,110030441223002,103010400120230,114120212310000,102424010230103,114200020210110,103110230210201,101403004020323], + 200111121232200: [102110142004430,114310100014104,102001020200310,110211244400301,102040214001410,111101002240300,112411002010104,110400031142011,103000324042100,101101000300000], + 100124214220001: [100010101043200,100030100004000,102311210221101,100401320020240,110201222120421,101000011020103,114121202312210,110010402103240,102403004020021,110040421210032], + 310304311200040: [102410001402210,110000102100012,102010020223010,102120214001422,100020201221000,114201200004112,101400201100022,102141431343320,110010444410200,102010101130000], + 1100201114304220: [112004300230022,110202001000101,102202101300230,114000102304201,114221124140000], + 1411020200331011: [110200002031302,102002020243020,102040021121030,100311314310000,100000204130001,102041130200101,100412441010422,100220031001210,101010200312020,101040204210210], + 1044022301110402: [114000000032100,110140102142200,100122124300010,100110034101010,110410224241010,111300402201232,111011100022010,100400444100202,102004000201030,112020401130100], + 1040020040030020: [112113214020100,102010202004402,111130312211003,103224041400220,100001321032243,102104244000010,101001010300404,103340004020422,102410220200004,103113010102100], + 1032310201201331: [110413304221020,112130010202041,102012404000211,100110214103200,112020112300102,101030320322101,102322121000140,114140002313010,114040124102130,100002001021101], + 122031421042034: [103130314001202,102143314000241,100244210034300,101100322120020,101133040012001,103302320110042,110112324202034,100020321212233,114042324104012,100001101222001], + 1000100024120002: [112241020202432,103341411403412,114100130002210,100100001013001,112401002022010,103000214012340,100004204101200,102400134001010,102001004014032,101321040311120], + 1120432001140211: [114003212210013,110302012103114,103023101400002,110010120440200,110024140022040,100002100100320,110100034200300,100401201010220,103200024021204,102100204000234], + 111402030002020: [100200301002001,114303120004402,100444004302301,101030224211010,112200002010004,102000101410021,112034222002010,103020404002111,112010230210110,100201040012000], + 1010031002102240: [102022000210010,111201240001232,100020301020413,110421202220142,100204314320400,104121410021020,100220004311122,101230130041001,101042034041342,110404034223424], + 110021013020313: [100022010100002,100004100410134,100102014301210,102430144043230,103100130102014,101023321002102,100012030122000,100020200120000,102020024003420,103111230210043], + 132033102211110: [102020221411320,231011321002242,110001332002010,101421101011202,101143201101212,100021341042001,110400131001004,110411200000004,114041104100241,111044212143023], + 131132404101202: [102110141401203,100003021041343,102040034000131,114111302203401,112040041120040,100341001003013,110002341300120,101010011000121,101022140300332,110140412011321], + 1412234223200101: [100020021042003,112404212020403,102100021341110,100002000100120,103031041400001,102022412000010,102300341002000,114002304100240,100100201020222,101000011003244], + 100210020000001: [110011414240022,100000200202012,111142010020301,112114324040000,102124031023100,100204104320231,114002104020100,111222214101043,100010021034000,103132004002020], + 1401424102220030: [110013202003320,101031241000010,102120231343224,110030332100203,114404232310120,103100034001310,114002202210331,100031301020100,110111032140220,100020010200022], + 1000002322230111: [100040301042132,101021104212100,102102241341004,103031000121000,103002020101431,102020300220201,102020431101132,100000041020230,102041021121210,101404104000404], + 1410043040014040: [103104401244021,112031202003020,104114400011000,140402143000011,132344004001203,100210134104040,110422001144121,110000031031240,102110224004010,100022024300010], + 101000122104200: [102041310200042,101000304014100,100040011023101,110301030010140,104100002101431,110221000111302,114101420030202,101123232010002,114421242204443,110100222001100], + 110203202020302: [110041400410001,111010002232002,102402104001124,103210300212001,102023111131000,100000441022011,102012010200010,110441042222033,100040224101210,110320300011130], + 1144000100040220: [110320202023400,111431110000042,100302141003012,102004441124110,103303201400021,114101420030202,100000301221024,101224322120022,110104422010121,110302204433321], + 1032023214001301: [100002100100210,100010001032223,103020031403100,102200401111200,102000430221040,114003104031111,100102020411200,114221030000011,114200302341234,103002110100200], + 1104101020020230: [111220204101421,110042120021013,112200420200200,101001010300011,114012020044224,102122401340101,110021020001220,112001024000200,110112030401012,111112204404021], + 1100032122422030: [100220034322312,100203104322011,100021101021200,112002224004011,103240321400010,102010134012140,111102002240013,102110000210014,111101142110100,101002114000002], + 1141000001411102: [101001040340004,101013004002011,112022334022101,101011324004222,101410401010030,103210241422022,103240001403000,102202204040220,102121010212140,110020124200230], + 200220014302300: [110300100100200,101000224003200,102110140224010,100024101020044,103140024002140,100103240011013,101020120322020,102020011103400,110222000000130,110120021324222], + 1021241323320104: [102404004041224,102200041120220,103220010101140,101140014001001,114101002200223,1034110304101100,110021041330000,114321140000202,121102001120113,103322000111220], + 1140020120203220: [101111140300020,101240301000140,103100014000001,103034130144031,102140200212214,113013120103104,100200241000143,102010031101223,112401102020023,114101320030004], + 1403231230440022: [100223000012020,101123031111011,110014300001402,110120424221121,101022011140403,101031411140420,101030114013043,101042301120010,114423312201001,100104044230000], + 201134111400004: [110113314221413,112004310224204,102304420211002,110403042110030,101221414041100,100032424312011,114112132313033,101110301040312,102204010204023,100220000432400], + 1013111302201242: [103300344012201,100122200012014,102313204114304,100011200201400,100201104224131,100002100204114,102203001300000,102101004001020], + 1001001423001101: [110330400010040,100101231004020,110010100022010,111000100012002,110022140120012,100143040411011,102404404004104,114002202302000,100034000000002,100400100031022], + 120112010202304: [100010104331200,110010104201022,100012031032234,101000204210021,110100121224222,110002142120000,102011011321024,111132300020000,100022301030201,110100100030303], + 201020143002010: [110020100042220,114200302320443,100401111000221,103302010140122,102113101400001,100010001001122,104240202023232,101003114010200,114030204021200,114000022210140], + 123431202011002: [114330014002002,114020024104430,101040214213002,102010210200102,112002040214231,102100222002040,100011004312001,102033041412332,101014240302113,100011021000412], + 1240321040221010: [111311002203000,103301000140120,100332111004200,101033220300404,101440410300202,110013002101010,114401020031002,114020204104030,103243024023000,103232031411102], + 1121243200030001: [110200002031302,102040021121030,100000204130001,100412441010422,101040204210210,100000201034001,112020024000010,102004014011022,100101234002000,101420244021100], + 1021120022012002: [114031102200100,110003010010401,103010010104000,102330030243120,102100100210033,234131201024402,100002200014412,110040311213342,110010102234002,102003144000043], + 1220040022001023: [102000001132113,100041000010302,112004202302034,100042001020203,102002320220202,111321314133000,101131024020440,102432101112141,102100044000000,102104442004300], + 1043404120000203: [101004100331003,112131222010010,103001011400102,102000011102134,100002121032011,114122224003201,112034022311032,111001420021111,111100214400041,112020102002024], + 104301030210000: [114002104014300,102000311102212,100130320031042,102010004040000,112433112020200,112301312020123,100042001020203,112023032000020,102000201101332,102231041120104], + 1210000221304320: [114200110001402], + 1002203002000004: [114022300022421,114401200000003,100241001003002,111310004122000,101221000312044,100400240013333,102030300224002,112010022000304,103100040210040,100210001002200], + 130402220300213: [111231002242010,114042034104243,114000214012010,103232114040140,114010002240111,101020401034001,101440104002230,102440214020040,110004124203400,110102032010323], + 131310204030240: [110212301300020,110210422110113,111322300013200,102202001300342,110010222000110,110433011310111,100210434020011,111212224100024,102030104012411,114200002321340], + 223002002023302: [102231130213210,100043324210140,114113104123200,100020420121003,110002021121023,102300040221403,100001104301200,114121300224141,102301100241002,112002104003412], + 1140102113002221: [100000431020101,100244100032320,111102420023101,110010212101240,104104001243020,100032040000331,104124102100301,110002010440412,110111420033313,103100200103020], + 121211122030300: [101211201202134,103120104030100,100004000100101,102020030220200,110031404423144,110003434410403,111110000014401,101004000304012,114002004100140,100022210410130], + 114010032200111: [102003004000040,102011101131021,100021100013401,111010110042210,100114200020220,114401004122120,110023031204100,102431411400001,114023202330100,102041114040102], + 100000001100202: [100021230411014,110024000412302,111201024101100,100203141001002,102123020230114,114102204121201,114401204141201,101124000330204,114043422212002,100000304310200], + 1043020200022002: [100020220410142,110000412003001,102011331131302,114000230023300,120202201010210,102021204013000,112042024000020,110022100044100,114400200004310,110003000024101], + 132001114401013: [100030200102434,101101230010000,101422401012100,114103204100320,114020012300203,102112410222200,101141041022031,102000044000420,112300001103204,100001001021223], + 1004004102101101: [101100120330110,114141302341111,112400020200104,112212220223012,101002014013300,102100030222104,114113002340212,111203010002220,114104120220323,112134100421303], + 203100022301203: [102401141113031,103042420143020,110210400002012,113032012204012,100204311000400,100403012200201,102011001002000,112002111121013,114211100001224,102112004004002], + 1032011304303210: [112300020201040,111200400003200,100002001003103,110200010000103,100020324204012,102021011130413,102022001131012,102302214110042,112220020202300,111222002220000], + 201102440003011: [102040431121110,101221020040220,114111100021420,112024212301420,102212000200124,100300310140241,100240134323001,100103104302044,102141212000200,102042000222002], + 1003010041242224: [110230000000002,100004414101224,101003140322000,102002001130001,114201142324042,102213401111223,103211104021300,100011200101113,110112030121310,100000100412021], + 101210210122022: [110020301220324,100041000010302,102020100243032,100031001020040,100104001041200,102012200202303,101110404021211,103110041442122,114210400000112,114042014102321], + 112020211002020: [110041030411301,103301210142043,100002024200142,101110044200100,102411000200000,100400014321101,114100122342002,112012020230301,100010101020023,110033041200104], + 1412022323211302: [111120002211010,101201200310001,102023120241131,102020000201200,104103101240204,114241000002004,111232000010230,100424200020200,101020320323422,114220200214400], + 1021100100102111: [112001232000034,102100021341223,114112434000040,121000041000010,114001002304222,110142032004410,102113232001100,100122210400030,101140114002200,110113211003124], + 1101220000020110: [103204214040130,114113104123200,101210210300031,110002021121023,102201100200430,100114021040000,114121300224141,100021020412110,103110000223000,103000210120000], + 132134404311000: [101020100300420,100200021000412,110330000400112,110000000130104,110103041012020,111233314101101,112101100221122,114000212301112,110000020124221,101000200300221], + 111004200220243: [100000210100030,100402042200000,110001440041003,100000220111021,101000430320220,100401022201110,101100001110030,102210011101110,112100302012023,100402000010203], + 1141002203100003: [110013202003320,101031241000010,102120231343224,110030332100203,114404232310120,103100034001310,114002202210331,100031301020100,110111032140220,100020010200022], + 220211320214200: [102121201340001,110400242110410,111302204123234,100030020423044,103013104002044,114211004004210,100034204310001,110011340001104,101023011142204,110034220114031], + 130002321403110: [103020031403100,102200401111200,114003104031111,114200302341234,103202430100244,102302331003300,102320000221020,112131004020212,102003211120021,100033001020140], + 1000212024422033: [100140201011204,104010100010424,103010014013304,102103030201001,101203104200224,100010221031023,100140000024021,101223024200014,112240404012020,101201024203004], + 113101010422232: [114130012310000,102112432004423,100243120430140,112214431102032,100400120013011,102211241120212,110120032013303,102101230310000,102323011101210,114420000000420], + 1101303000341000: [110124010031144,100021100013401,110311312000001,110010320023302,114130202311020,110002042130032,110244000000020,100003021032001,421432000003000,102210221121044], + 1004102042113300: [111100214100402,110021130004103,114041302322043,103204324031320,112430002022342,114220212340004,100241004324000,111102310012110,103200011404234,103140244030030], + 112004341000001: [102300324010203,102100142002204,110113004402201,100001134100120,114023214101310,110301232000100,110102400013020,114110340004414,110303401230040,110011200020114], + 133011200040220: [100002400100121,114022444101022,100004440012400,100001000413102,114100044004101,120222000002200,110001002130011,102202014020040,110001344200402,142402303420001], + 1010411020110302: [100041200010000,110111001300044,111000002202324,104132100011024,111211010001300,100113434301241,111014014401303,103210001422303,100100000022131,112042111120340], + 1120204111221101: [111420012101422,110444144241024,114120030020202,110201002010420,102001101130120,101004020342000,100230410112111,114224012330022,1000310103100002,101240010310200], + 104003013104100: [114002104014300,102000311102212,100130320031042,102010004040000,112433112020200,112301312020123,112023032000020,102000201101332,102231041120104,100111304300020], + 103010421110403: [100231401213132,114210104113314,114021232300112,103001000120444,101144024000232,101302121004422,100000010011430,100114420000140,102022300241201,110200100001242], + 110223002344104: [110400010031401,114112002313010,114022200031221,110100022040022,102100401410022,104440000012304,130430101032200,111024240404104,101001004012010,100113120033040], + 1100103312223300: [102222320200001,102024101321401,101100021101232,100000321040000,101010001000432,100134101022112,102402004041120,103310200110020,100020031030323,103101200100001], + 1122320140101221: [100203344301100,101000110300300,103420104020200,110131411300312,110200124240014,103100000124010,110030414202400,110032040000332,100011011200212,114200024101400], + 132213141012022: [111113202211020,102000100202041,101021041001434,111200024131220,112004030241132,111203034440323,100232004221200,100201000011432,101042144010200,100112401020300], + 1230000101040111: [102440001113120,114311204002010,110004221040341,103200204031212,102313114114000,114004102201202,100000101001431,101010014001032,100222014121024,102340140222011], + 1003024441100101: [101220111020012,100004024202000,114200020003000,102112430210103,103000114012224,100033131043244,103000024040413,111102002220124,114423100000411,100014201030221], + 124002102002000: [110041030411301,110001041213031,103301210142043,101110044200100,102411000200000,110414300030001,100030020011022,100400014321101,114100122342002,111202012222402], + 131043001013100: [103301210142043,101110044200100,102411000200000,110414300030001,100400014321101,112012020230301,100010101020023,102000221442214,103142111441040,102140101343110], + 1140102323000314: [110200002101020,114104032211214,102410400233132,103101011210300,114213002320124,102200200240031,110011212030112,102101114021130,102012410213213,102002010240020], + 1042032223340200: [110340014422102,101022400300001,102140004000100,103202130122102,100021000010213,100004101033223,100231004220242,112430010114123,130020100202200,120002101133400], + 1104300420300020: [110301012022220,100000130410014,102303414113320,103401344004004,110010114200400,102201001122034,100132431021202,103122110400104,101001211002201,102100234001041], + 1010123300040300: [103222100212012,114010112201001,101224244040310,111323210000204,102001030240003,121102200401021,101001324214240,102301010242231,121244120211020,121100000400034], + 132041000031014: [110401004221204,111112000011222,100322444314002,101003301020022,100001030100030,112012004004000,112044204000441,103141100104002,110341300400201,100000104210240], + 201022320130011: [110433012110300,110440201342022,112101414041022,112243340202002,111103412240000,101000204003420,110101240024120,110300310011030,100230101001020,112021300220021], + 101114041010101: [110102042010220,101020124000413,111210000001101,114013400011030,101201104040034,102202000201220,101020111030400,103004104010210,101220024041000,102010300201414], + 122430010030030: [110403302023130,110001004204310,100010311020030,100020000200000,100141230020203,101031121003021,100200120030203,103111201443022,110101214400030,114104040220130], + 200110400021200: [100300041001121,101240004011021,101011001103200,101002244012322,102302210210322,100012401020212,100003131040012,103004044010300,111210004101111,114004130020232], + 130021140213331: [114402404141241,110212022133311,101041210311410,110022004211030,102104101122100,112230240412241,110000204203220,100034141030202,101000300312123,102204141300100], + 1410110013004410: [102102000233342,103302220110131,110100111121002], + 121212010020410: [110330400010040,111000100012002,110022140120012,111102010012102,111300030012334,100143040411011,102404404004104,114002202302000,100034000000002,100400100031022], + 200013001002114: [110442104221030,101224001202324,111211144101202,100002001024100,102103130221330,110000300140010,103102134001111,102011310202304,100003114100011,100002314204210], + 312124010300220: [104100012102004,110030002000422,102102011413000,100402431012022,102403404004110,102031024013013,110044020020202,102122410220401,110021232000021,100001140000010], + 1000212113420430: [102002040220110,102141220210212,111202024134001,100000014100202,111302120011012,101012104001020,100002314210021,103101031440430,102022001101234,111422202210212], + 120221011100303: [102001404012100,1010400230221020,102302200210010,102340120222440,114223204100010,111041202200140,111300400002313,111101040014040,100023014313010,114021040010311], + 101004101220212: [102023104002000,111114010020011,100001204302200,100310111001140,100000004204201,114002104011010,110001221101201,102000031442000,102400014020400,110301011230230], + 1011110400240232: [114020000030002,114031000022030,100201211003004,102014002000401,103103241421322,110110200001000,114121012340044,102000400240203,102104304023201,103310300140324], + 1102202110002002: [101222101202341,100020220410142,110000412003001,120202201010210,112042024000020,110022100044100,114400200004310,110003000024101,100010024302100,100000011020412], + 131110002301301: [102224101113104,114202144102100,103000214012040,100034140011211,102333204110024,102103002002000,102402001403121,114114300221122,100044334102300,112332301100223], + 1034021200100143: [110300221220031,110201220000032,100021214313034,114300200000110,102000021133001,102301434110030,122011001202102,102100301400242,202023004201110,101001021001033], + 1100003040100031: [101030000320122,100310301000321,102001002000000,102300010221100,110020004413300,100121320401222,110021200040000,100301124210103,112211024013040,100040014310010], + 1124201010140100: [100111011011011,100030040101021,114310102300021,114014112300100,114030034013101,102400124020001,100102224234101,101013004001421,103000014011004,102010321411140], + 1022210110130021: [1300422220310121,100422321032021,120032010212320,411001103222300,411311131413022,1220101103414143,320440200013001,410000244003240], + 1120110020011410: [100304201000221,100112021020320,114212104110100,103010001422020,102300124023122,114221004100020,102304100210334,100403210010142,100301104104210,111022134112141], + 113022000112320: [102300000221114,114301000002344,114212310002312,102104014001023,110200442120120,102020031123000,100022101040044,100024000102402,110043301220422,110022400021000], + 1100100020220202: [100102204300424,110102221014102,102002010224011,114000030042240,100200020320224,100011010022200,101403144040010,104133020011042,110031132130311,102022001440012], + 200311014111000: [110301120404342,102113304130002,103124420221210,114032024012040,110100000100220,112000210210301,102012124012120,103431021204400,100031341030021,101014004001312], + 1010300002120034: [111102420023101,102102244000330,102140140210323,102001004012322,100004001041301,210202011010122,110420104220202,102320420240300,102222131120032,100203101000022], + 1211000020003020: [110230000000002,110220301202400,101003140322000,110401001002400,102002001130001,103012000100400,114201142324042,102213401111223,100040120000031,100040030122003], + 104130311211041: [100002100100210,102420424042020,100010001032223,103020031403100,102200401111200,102000430221040,114003104031111,100100000422320,100102020411200,102100012002000], + 1101112101300324: [102000001132113,100042001020203,102002320220202,100120010421220,100000201041300,114011200003102,101020104000040,102432101112141,114412142320040,102100044000000], + 213143030122200: [100032041021210,110004301222000,102040011121100,114310000001232,111202012222402,111322234130000,102040041320010,103203401400132,110104002010100,102042204000300], + 120024032114020: [100102004300104,101020004011302,114212100023341,102300021103201,102410101112322,102121041340000,110010140011021,100123014103104,100001011120400,120131201313314], + 303013014000413: [100022041030000,110100104403201,102202000200010,102214204040420,100010430202422,112340020203003,102443011400041,100010430022021,100002021031032,100403022201202], + 1020203111100020: [100131424302300,101212040011001,110201344402000,111011242233002,102320001000230,111110223004100,110020212130021,101422404040210,111040224110141,100120041224204], + 222010011014131: [111001440020003,110200020010003,114121000002140,100002214100100,102120104003011,102100144001112,102000041441002,102120402000014,102000200210032,100041000100422], + 1430130300002324: [102100201440001,110400011311001,103300120141130,110040002132020,111144202220301,100000000120200,102304011004310,103101410212231,102120044002231,100002404210001], + 322400301320302: [111321220003002,100332104310222,100003201212143,112000014000303,110120200000111,102000010204312,103220434021030,110211200101114,102122001402410,110430001110403], + 1020312101344012: [102011114002011,102042100242012,102144201402040,100014201021012,110000214214420,114021212301131,112010112000311,110030441223002,110440002111230,103002044010020], + 1122122000102011: [102202010240210,102203101120000,100010204102001,100002010102040,112104000200322,102140201401023,100414000433302,114120000000300,103032224000200,102103200210010], + 202213212001411: [114001024011334,102312144114200,120012102310332,101022220320012,103023404040213,114211000210320,112103000204401,103100004001120,101201114041014,102101034001100], + 320214120004400: [110204034240010,104102030012121,110000011100204,102420001110401,101021111000022,102100111413012,101422021012014,103442014000100,103132014002131,122120120140231], + 1040010003012010: [100220034322312,100203104322011,100430020001120,112002224004011,111102002240013,102110000210014,111101142110100,102000411410342,102310314114031,130200211400203], + 1121100230120400: [101222101202341,110301442021010,110001332103022,100010024302100,112041000220020,102022400210202,111304202202230,111300000001323,110000002001040,110101000121214], + 1000110011013122: [100002104204000], + 1022200103210210: [110010020020011,100000001221100,110240242120033,103141100120000,101200400303000,112400002013000,100120440000022,100010314313000,114310424030011,101001134014021], + 103001300220211: [110111001300044,111000002202324,111211010001300,114030020020301,111014014401303,103210001422303,100100000022131,112042111120340,100101141042243,100101100022012], + 100122244200330: [102130020200000,101104020300301,102004204001111,102101004000011,100002040102100,110023330004130,100001104303411,100224204323201,110201124211431,103004240101010], + 1200204124402002: [111302020010000,101300221003002,100000121020303,102403004020102,110200220010220,101000001001114,110020004203240,103303021404201,100020010420242,100100204232000], + 142002102104021: [101000411030013,103012004020122,101322310313010,100000000410101,114403020000214,100003341020020,114110104121414,101313000312100,100040424212200,114040414102120], + 102411011130240: [100011010414200,110430000400002,111121102240240,111320022200100,114000100020002,114104332310202,114410102310421,103131121421321,102101331342000,102010321131241], + 202304002020040: [100000220100001,100122230031414,210303212040010,100000014200104,114011120024030,100101121010100,103002011240201,102440024021100,103231014021201,110110420034120], + 102204104000000: [114201204111222,100104001041200,103300004021200,102004204041000,114210400000112,103230134011412,100012004101221,114122112202230,102301101004100,110432112111103], + 310404203100341: [102011201101012,102300304110030,114412000003141,114120430002002,103020041420212,100112011040011,114033300041020,101201220300012,100401024300321,100102030423010], + 1122001024210202: [114010330030011,103021220104200,101010020320000,112000210211020,100010324210003,101000000343443,110002400011111,100402132200000,111100300024000,103144040104204], + 221134213203000: [100121230031032,112000431120410,103042024040104,102304104110001,101342300314204,114013124030022,100013200100011,114104200220022,100021221021201,110001244204302], + 320031312101204: [100020001044100,1340120100441224,1301223001003430,102330042000001,232020104433104], + 102241201232300: [101413321300222,110304111230123,100031004101000,102003011120001,104101420011121,114200224001003,110010141221420,102201201002010,114310224030143,111214003022100], + 1043331100042020: [100021204100204,110211020000002,111230214102412,100113410410320,111201442222420,114012000022010,114222440003300,111022120023311,110041341300041,100031144310241], + 1000404012003420: [102301000220000,100024114340002,110101231300241,110000140132110,102402010221231,100304100140104,100213444314000,104132100010310,100241000440432,110411200400010], + 212123200410100: [110002320424340,102031100200300,114102134122020,103010034004303,102023032000000,103000204003200,112300020200242,100021044343014,110001002002424,111100404100043], + 140000222031301: [110301042101400,112423414042122,100400320020104,110001404210000,102012201100202,100220021000001,102011210242012,100114330414120,102121314001202,101010001030001], + 111112010310012: [111333104124202,101000304014100,100040011023101,101123232010002,114421242204443,110100222001100,103102000121300,110010331230210,102030020224102,102430014020010], + 1012000440233031: [110041240000013,110131122012210,101021000341001,114010200040441,110032014420232,100012044101230,111304022202211,111021212200430,112010034020230,102100010222101], + 1100112304402303: [102001000212142,114121000002140,110024042103114,110123042010000,100041000100422,114020002303212,102223231121242,102103132002023,100024121030022,100000020001022], + 300100043121010: [103130314001202,102143314000241,100244210034300,114001102211300,101100322120020,103302320110042,110112324202034,110031422000002,100020321212233,114042324104012], + 122431102040020: [102021001132040,110201201211024,110402420402001,110021021210300,110404000000012,102000101120123,110221022101104,110023100402320,100020311220412,110123004401121], + 202011242024002: [103114204002100,114230004110101,102122101023020,100001101033010,102142002000030,102023110221011,100100114302030,100100014302013,102020121130000,101204031024110], + 200012020220101: [110202012100020,110013202003320,101031241000010,102120231343224,111342020011220,110030332100203,100314114322101,114404232310120,103100034001310,114002202210331], + 1414410110001200: [101230114202200,100400000020230,114300124030100,102211020204231,112011204004112,100202031002101,111000004401312,101000034212001,100121114230123,102321014111202], + 1114201310030110: [110132010032031,100200044102003,102210430233001,100110231000142,102420210200041,101003204003100,101312004211100,110010030101400,111022114120310,114003422242201], + 1101002041041001: [102402434020211,114103002311110,101004344002124,114020024120011,100001001032400,102402030203003,103022011400040,102011011133120,101011411002311,114220102331110], + 221241002003004: [102014130241422,110001002203134,111001002201122,103232040100100,110212020100040], + 221000241023300: [111201000013222,114004104012300,100021014100123,101203211010000,101200314040213,112032020220030,102320120240012,100003021030220,103101324001100,102123021022412], + 110004430041000: [111132230010402,110000400023242,114000004102010,100110014032131,110113041303100,110100314401022,111301102204130,103010104011202,101020220310112,110000421320024], + 114103210330002: [102440104021410,102012214041011,110411344210012,102010214000220,100100014322200,101042134014101,111141022224102,103004030120101,112221404014110,101032011143223], + 1000004213102000: [110443000000102,102430100200123,100040214102300,100002214202010,101424010303040,114042244102400,100034400410112,111020012203011,100100111043114,100000044241022], + 143210020000210: [101210331023020,102021111412201,101201000011000,102322124114210,101011211002010,104110411304420,101401221011342,103200004024040,114220000002123,100010214302012], + 1010222200110100: [110323344422123,110011010021004,111220002202002,110112001343021,100002101020204,114212000211041,100431204320300,110001040020213,110112121200203,110300200013040], + 201113000120214: [103211200100400,102112231020231,100022004300020,102320000240102,100042144200000,102030304001101,100020420121003,103020004011414,112002104003412,114201204111002], + 1011213312000014: [111200212223002,114141044000340,114020444100202,114020232302203,102320014112013,114402000003130,101004001001201,101001000321032,100023100104410,100024000010031], + 200200022302040: [110140201222000,114112232313023,100102001000010,112032200230231,112312420202020,114130004004200,103000031240330,101020304002132,112220004010404,112102400202324], + 141201040004004: [100034304101213,114002014100310,112023140212112,112313301100030,102101031412121,100020020121132,102102010220401,100001020100030,100021120201020,111000024404021], + 220320200002034: [102100010233022,114313022302101,103001324000110,100002014200021,102300401001010,103212320212011,114000030014400,111120034400000], + 102201300004002: [144131233204044,120130001004000,101001131032132,110102030010210,102220211120002,114014010033321,101400104042212,1003022312322100,102001244001224,103441112000230], + 1403121024040210: [101020024212042,100041204212120,100410110420202,112423424042102,100320431000002,411200101402221,100120214230002,103204200103440,100210004104001,101410201111300], + 220300201301120: [100022041001002,111240340004003,111101222244030,114032424122040,112011012004300,101021401003220,100301020420101,102002202000000,100022024100041,102010410213111], + 122303001300104: [114211440211420,102200024042003,114320004030033,100231411001200,111010000022022,102112200321043,101000021140240,100001011040221,110221102221300,101021311001001], + 111203120100014: [102044104002014,102022000220004,110210001310230,103001220104301,100010144303000,100102434300310,100421200001003,114024200040223,100133404030004,102240001100210], + 220020202243103: [114003010024040,123102202010320,101020211140102,102104120200134,100120230012241,104210140212241,101112240323103,110203232020010,110043200023212,103441014002310], + 130230234000404: [140420100400012,111001202231001,122012440110401,202220202402001], + 1124221120201422: [100040201012040,114100222310230,114131002342130,110002022003101,110224130002014,100403122201202,100100220403100,102303304020122,100310210142030,114132012200110], + 131344111020111: [100001024201214,103433121201311,103404001214121,110113211301114,122004120000100,102300002103012,113030410122021,111400202101243,101012114000111,101020211140102], + 1040302200342312: [402000401204030,114124020222032,102121221343020,100140201000222,110110000004210,101400010303002,104200202141001,112104424022201,130030220200012,112200110000221], + 200002300140211: [101021014002020,112000404000001,110320332022210,102230040200111,111241000001011,100240034101400,100220304100400,102102004000001,111000412203041,102400121110000], + 134200201020210: [114021412213020,110030002000422,100032121024110,100402431012022,110040002034100,102031024013013,102402330230011,110044020020202,102022400211311,102324410243220], + 112120200100343: [110130102010010,110100030123401,110001010030000,110102202013213,110021404214210,100003110022310,100000400100142,114102000003021,102220314013103,102002034001310], + 1000144202110034: [103033004011100,111320122204241,110132212010200,101000024000022,100000204310440,110110100033221,110000224410201,110100400020121,110011304200020,102030021102211], + 1004033332023033: [103214010102022,100043324210140,102324014112020,100023024211011,102404021403141,100010004313001,100003201021001,100122020011232,100002200410030,100121031014040], + 130220204001330: [101400004021110,100000241120103,114232000002310,100402000000101,101000114003100,102202301300240,110010044203000,111010014400030,112211030204411,110210102120000], + 210002202200000: [103211144033404,102123040212103,100041301021020,102314224010213,112113012010000,100000120000202,111000030043110,100002314203420,102001121134000,114220414000310], + 101220020001403: [102342014111202,114040002330341,411010033020221,114102020422002,1224320120024001,200002003223300,1000412032200202,300204110434340,111100001002113,132220124203004], + 102120012021134: [110400000002213,114132100210100], + 114000223000041: [100011200121231,100102004100201,114040020021023,111230114102201,101400300300111,101220200301400,100001101021134,102122302000300,100000300202000,101022031034002], + 101110430324122: [110200002031302,101403220331230,102040021121030,100000204130001,100412441010422,101010200312020,101040204210210,100000201034001,110000324412304,110000201230100], + 102113104000201: [102041310200042,110320202023400,111431110000042,110301030010140,114101420030202,114421242204443,110104422010121,110100222001100,110302204433321,101010001002000], + 1000302330420004: [100000020004101,110130014400011,110011232100412,100220040142222,110232002101410,110200021210212,110131021240303,103100101442233,100424331001120,100000031220100], + 300220113110120: [114021000012310,101042410301221,110432300102000,100011004102400,102304000210204,110040344210011,100020120101000,100003200020112,100400231000200,101000100340001], + 1004301013110120: [103310020140014,112000204002100,110210030100111,100041200002402,100000000411240,102030021443010,112300220202122,114010000024012,103100421422110,112120002302004], + 212044320041421: [100244104101010,100200011002201,100211310140340,100200024104410,100220011004202,100000101232030,102101200200034,102243201302244,104430421104102,104100402102320], + 1030202410202120: [102222111120010,103200224033413,102300440221022,104120201242031,102320110240231,100100101011200,100133001220421,100122204301312,101022220322100,100114113200203], + 110020300043342: [102112020222030,110320022101120,100022431030100,100022004301043,102214101120310,114000040031021,102400001110113,102002224011000,101030204214013,100004201211032], + 120220023043020: [110024404211001,110100022010010,100120001040202,102140140210112,100004220412010,101222020304402,101201130302002,111020400044101,411120024124200,114202102321131], + 130300014233341: [100102211021000,114203142321301,103141011240230], + 1113010112422040: [101012131000024,102120221022200,102110141410402,101044001032114,114221104114000,100001111032112], + 110020210041024: [100020400410010,102103441142340,101211210304010,102100001004041,110000403400000,100000414104102,100001020044101,410310420012412,101000020100020,403002310120143], + 1003113220430003: [102422114040010,102020004001311,100101101010100,114103212312012,102321044112101,100022024100041,114231212342200,100020011043020,100021231020200,114201112322020], + 1101000402201400: [102000004002101,110202000000310,100422314300200,101403014020203,102141410230020,100042030120422,101134224001001,110020001224021,112100000200031,110003032000041], + 101002121200031: [101203231002222,111430032210010,100000204100040,101003030304240,112113224020012,103002211240301,100220120432010,100004014202422,110411232110220,110220042121003], + 1141011011423232: [100012014341003,101100411104001,112111010201220,112222122032004,110100134403210,102300210242404,114300432300422,114101144001040,100040414212104,100000424304010], + 1410200232000002: [102422114040010,100022041001002,101204400304011,114032424122040,102020004001311,100101101010100,100301020420101,114103212312012,102321044112101,102002202000000], + 1042200002202040: [111223402220443,110430000400002,114033000032021,102401004043011,111320022200100,100300001002041,103000200122014,102203001120342,103133004002010,101202330304024], + 213021140040011: [102230040200031,102101204000010,114230230000123,104121001242101,102024400223212,110040004411003,110211110001322,100014110201012,102200310201220,110300014422013], + 1003112022201200: [111000022202402,100430211011410,110010340040012,110014032101430,104421312102244,114131014101010,102240214041033,114200322333401,103010021422042,100000001022401], + 1001031040033013: [110023401320200,102301224110000,110000312001020,102133211401043,102010214000003,114032204104044,103002010100104,100220310430010,102124011340031,102410110232000], + 1020014220203011: [100012320001320,102000331120104,114040300043111,110203111111000,114010030024204,102010201012014,102041204000002,102323204112320,100402201004014,100420404320101], + 130003010203330: [102211220201114,103000021411202,102101004030220,102003001132213,102100204030012,111432000004311], + 220210100042200: [102102430310202,101020030332430,101022004214304,100020101031131,101010000323030,101001414212120,103310220113140,114200202330330,103101101440200,100000101031020], + 1003010414041111: [111200200000232,111410210001002,100101001011114,101430004040203,103122104002013,101020404210020,114040414014202,100000024301031,112022140234004,100143440001301], + 312040323040010: [101211104040023,103042004001000,114233024034201,114030002301220,100221100432104,112003120220142,114010430040320,114303222301000,110001022011241,113423202410240], + 1400412203240330: [101020341034234,102113101342000,100212304243333,100431001010310,110002010042440,102022401412124,100121210402002,102212004030221,100030404311202,101410010330014], + 1024110200120012: [111300232202103,102301401002404,110122120100022,102012004010000,102400100220000,102001104012021,100242444300104,102002104014323,100401241010122,100010010102122], + 1040202023020134: [100000020004101,110130014400011,110232002101410,110200021210212,110131021240303,103100101442233,100000031220100,111010000021300,114200444140203,100000124211001], + 1100220301211442: [101240210310204,100000021023020,100100220423210,100231020112302,102000111441024,101110204004210,114240000000041,110004010004010,102210220202001,100110040020104], + 1222211202201004: [103111004004410,114220012340000,110102141201112,103112024030310,112210222040000,111100002220221,114011014010300,100000020413022,102244101111124,104103031240201], + 1201104001013221: [102000324040000,110222200103041,112411400202001,110212311111030,110000110022002,140143400110002,102042211100202,102010000200240,114000002302204,112431244044400], + 221100201100100: [112030004004130,101340041000104,104100212101403,112001102000201,110404212112030,110104220400022,100040020000313,110211130002000,110134310404210,101420000330441], + 1114122030000002: [110104112010103,111102004100101,102202414041044,102000104012232,102021100220101,114443330001442,100230120001003,112042110220004,112203221102231,114022400020320], + 100142421420401: [102002212000021,102013201320403,101134004004013,112230122032000,114300300000020,100020001040312,102203011002032,101000324011134,114302022300311,102220301302413], + 212100201001020: [100200101000000,103110431441100,100011004340114,100011200121231,111201102224324,100102004100201,114040020021023,111230114102201,114201102342110,101400300300111], + 1400100010000112: [110230400000202,102012314004200,102112304002110,100432014100103,100104220412020], + 102430101140002: [102310000222133,114104310000002,102100011413420,100001001034141,112123102010143,102130201140012,100010204202202,101101404003003,112422320200210,112100211100021], + 1102202210214234: [102104101340301,101033011001100,110014010012200,100100004230402,102110304020201,110202420004101,100021220010031,100000014211030,100000200100141,111303012201100], + 200012204110023: [111011304114002,103000001402120,100020314304002,102120400200003,101020300320020,101220301020130,111012310000204,101222200301130,112340340203340,103203314020144], + 1101000220032204: [100000031211103,114210424101200,100420110312244,101420014021400,112230324002000,112320301100420,110101024402203,112001202000203,111034200010244,101122000320210], + 1002114144412000: [114202012340131,110322034430002,102323131001211,112023102003010,101010104011313,102000002041020,100320021000000,102034100223241,102020014021021,102240234121424], + 132032202211121: [110232022123020,103140044032100,100010240101221,102100010213413,101024011034002,100032224101400,103033044023040,102403101400210,101021410320100,102430010202411], + 1441300113003204: [110000021202100,100420014301410,100010101020403,110302030011010,100101300011010,100020111001344,100022121024103,114401032320120,101201124013202,114223002333020], + 212100103212123: [110120200032000,102140011140002,101211001023004,102204024011121,101012100320111,110311100001210,100214200000020,100000012212010,112122034022100,111230102222200], + 132114221021100: [100002010413410,101433010300204,114310100000110,112002020214003,102010231121200,100140301000432,114400022311400,110010220410220,114040010022000,101133104002112], + 222223344212101: [100000201020000,102030024112031,102401011401222,100002002212000,102114341341012,111420200002021,111001224121320,104042022102100,104030002100140,102104120200021], + 201140431200121: [100114234102203,102030000223410,111101312240400,100231124320130,114000010012243,103040424010400,101141111100022,100000404100021,101332011001000,102103000310202], + 102004443030100: [111302204133040,110300000011120,100000221020004,101213020304210,111020010022310,114011302300101,102420021400002,103221200100302,100432211002022,100424444303100], + 212024120403302: [110240301111040,111123014100000,114200000003241,103103404004112,100110120023012,101042044010040,112021014022022,112002322032030,101040401030013,111300002204430], + 1122013000001010: [103313111402304,102031212011001,100010044312000,110213220000201,101204034200001,101002200021030,100031011012000,102000141010102,110304220100002], + 1140001000214020: [101221020040220,114022412330004,100103104302044,101041030320401,102141212000200,101203121020430,102100104002224,102020004000014,100000211023014,100400001001300], + 1130320404222410: [103111001422000,111244302220204,100042100102211,102110030200120,100202140000111,101114000332010,112112211102024,114001032300011,100142044103021,101100010012423], + 201121430001102: [100030324200410,114202244112111,102110202001010,100031021033010,114011404103142,114200020003431,114041002212302,101002200343110,103332044032320,100212024322044], + 1001220024010440: [102011201101012,102300304110030,114412000003141,103020041420212,100112011040011,100401024300321,100102030423010,102101004022104,101432240300300,101232104042101], + 112220043001024: [101221422120021,103001024002110,100231114320100,100001000002210,100400320033201,110011402100202,101210300302302,110100012120201,102020131413423,110020204200342], + 200402011402220: [110341200403110,101130034000022,100120004230130,102030041134220,110000400142301,114414014142230,100000004302210,111001404111020,100024041230002,102000104044004], + 1003110001234320: [104132340011314,102203304123030,114012040020310,110000212104130,110200200004002,101000040320021,114131040224332,114002210021300,103230114000201,100123020032031], + 1203102204020140: [100000010202003,114234324112000,103200101401010,100002231021012,102400001110102,120413040002400,112410024040000,102300234110002,101221001202021,102111134001302], + 1000430300020111: [102021001132040,110203131211112,102301004110004,110402420402001,110000112100402,110021021210300,110404000000012,102000101120123,110221022101104,110023100402320], + 202100013022332: [111134204102000,110422200000213,101020031000300,110000400000233,112000112030300,110240010002041,110021040001310,102120001120141,101003044001244,100131121222212], + 212101100440000: [100031300002022,110210022120040,110000021221134,103002044002032,100101020402424,102201112000001,112211120202000,114211040011201,100020100423404,110001222202031], + 1040003320021143: [110010000111020,100430014323000,102011041320000,114240012324120,100022010022031,102014140200013,101240110302200,100031204311023,101232001021020,100012121040101], + 1141001103140230: [103000024014022,103010000100410,100040404102010,102203240202202,110002110021301,114231020001120,100100211012004,102340202000001,110020402100200,102023210221301], + 1000030000032103: [100102000022402,100000001033001,100124100031200,101010200321022,103304014010000,103123041444340,102200231120202,103342100110221,101021220300001,113023341020302], + 104023223104010: [100323401000042,110103020011001,110210410123112,101100004000244,101000014211204,101011204004013,114422004142011,110022010002210], + 1002220100110100: [100122420031012,114200334112132,100210204343141,100000104300130,102202401114113,102140201342144,101021001031113,100100124234311,100022004310010,100010114310001], + 132310100001031: [144131233204044,120130001004000,101001131032132,110102030010210,102220211120002,114014010033321,101400104042212,1003022312322100,102001244001224,103441112000230], + 1001303020002020: [110202012100020,102303010241010,111342020011220,100314114322101,102230130203001,102021401324232,111222102243400,101004410311232,101201034010420,111220410010144], + 300211300011104: [102023324010020,114000004103003,111131002212014,102110100233222,102120311402124,103140124002022,101042421021120,114013204013220,102000100221400,114241204001213], + 1041044202311111: [110401004221204,111112000011222,100322444314002,101003301020022,100102431021300,110200212041001,100001030100030,112012004004000,112044204000441,103141100104002], + 1020202240114112: [110200321303322,100010030100011,102012124012120,103002041402004,114120034123300,114010112332112,114204202332300,114121304121000,102221024044110,102030004000400], + 124300110101232: [102000004002101,110202000000310,110000010120043,100422314300200,102403404004110,110301311303102,102141410230020,100042030120422,110020001224021,110103111120042], + 300412012111013: [100040240004024,100010000002400,112000013244041,114020100001120,101002041000124,102100000231232,102030034011211,102000400221230,102122001404300,110441342010200], + 1021041112002002: [114020200020222,114330002323002,114001020042001,102202000240014,103014101432000,100003014100041,102100121342000,112404410204002,111222002224302,102214011120002], + 102334000202111: [100424331001120,111040300024044,111020232200302,103124000104424,102100102002012,110201014241230,102110431342142,114201410004440,100040331221012,114442130003110], + 102211130414013: [110310001202220,111131224100212,112000112001400,112111412011211,101240000302141,103414034000124,100002020110200,112410024043011,100003200400110,101222201020020], + 124001011241420: [101232314010241,100301300121100,110042400130000,103020124010320,100021300101201,110230022122031,104101201240100,110000011012202,112102112301130,101244324043222], + 104220142130201: [100040201012040,112021004003303,114100222310230,100011120000004,114131002342130,110002022003101,110224130002014,100403122201202,102303304020122,100310210142030], + 1000013140040000: [102311004012010,101020401033332,100012001023022,101104414002010,102112012004120,111112242211204,110422020000111,100004020021344,100100000000042,100000041201200], + 1041120100004010: [102224420201000,103013034012221,110302311302101,100000120002200], + 134202314303143: [110102401201204,103020200141000,102400100230000,102414034040100,100212030414010,101200020303202,102020041321410,111340300010010,114120420223002,102013224003020], + 1001420010000230: [1020102021344321,101030301001232,100104302001300,1001102321230101,1002001200441033,220200021120010,100021204230002,1401214001003110,1023121121030343], + 132200000042020: [101211214040304,110412001213211,102040234002003,100100021013214,110420202110040,101301204220200,102304422004020,100000110400321,114011120033402,110020330014410], + 103032204302020: [103110044003033,100123041001320,110310010113001,114414120002440,100221101003010,100300314101444,101130430331440,100002120004202,102200002021022,112123104020101], + 1131304130122001: [103010231401402,101011400302300,112003012002211,112002414002043,112442004040022,114140222200101,111104232241021,110013232131112,113022341002031,100013411042212], + 1114320030021030: [110202004211120,110223224433004,110341010044330,102031144010424,100302420120212,111212114131222,102140001441301,102223400201104,102342120222031,102221010201113], + 121002010411143: [103102300102243,102113020210120,111202004100121,100020004310022,100222220001202,100003100122232,102000414010131,110410300402321,110020014410200,110320100400100], + 1040211400101414: [110233012120121,100000241030333,100020011020010,101000204002210,102000131130020,110112210000002,100001204130442,102100321410122,114024004020023,1014400221004004], + 210200000101402: [100422211004214,102100000210002,102121010210004,114013214010111,100010004210020,112002100240200,100001404100110,100002044200330,101213110310042,101424044043122], + 1400413220404104: [100003030003020,110410000104042,100000040413000,100001034310012,121310232003222,110011300143002,100220021000033,112011312002001,102110201023020,101344331000033], + 100003101320110: [100010104331200,110342022000001,101000204210021,110100121224222,110002142120000,102011011321024,112311212021024,110100100030303,100043100103044,110302030004323], + 124100012022014: [101032111230411,103010110120020,110100032122000,101020210301131,103201004020101,110200001314040], + 103140020100202: [100023421041402,103101224000011,101144134001102,102200042000104,103002000104400,110114021000012,103002144042123,110012220002021,102304204110040,112020004002110], + 100021323044101: [110400000002213,101101230331040], + 102330100031011: [110120102041110,114002242304240,102100111341030,110213131203122,101203440304221,112114004043430,100002334340000,110010432000001,102111044004101,100121101023404], + 123000400311001: [101002204212400,114041204104222,102112300201410,100100121043010,100323120143000,110432111241204,114200200002223,112123142010120,101002321032002,101121100013002], + 221041130130032: [111120002211010,101201200310001,102023120241131,102020000201200,114241000002004,111232000010230,100424200020200,101020320323422,114220200214400,102010001104000], + 1100202311010001: [101010001000031,100021020104221,111120024101141,103201214021013,110310304430141,102113304130002,102000131131100,103124420221210,110201002043201,100011034302423], + 103000100303220: [110111222040014,110100000123402,103003024001001,102004204000422,103010000120000,114211324100034,102440234021012,100240011000000,100002030413101,103000310141142], + 1403120024024100: [103123004002102,101020000320220,110111140011114,114131304142010,110132011002023,101100020300101,114423210001210,101040024002000,114020024010020,102040111124412], + 1200302124321320: [101230002122040,101210241204043,104102040011120,111311120014011,100123011004113,100420001002101,102430121110340,102020121102120,112141104020201,102000024000002], + 241120112010000: [102000001132113,102202310203222,100042001020203,102002320220202,100010044300003,114130210231020,111321314133000,100004410120102,111222214101043,102100044000000], + 1041302012300000: [100002014200331,102012004000003,100411000030110,102041201121230,101000210303342,103000121424330,101012204221200,100300114310112,100202004324322,100143244100101], + 1040120000222002: [100024234201100,100010234114300,100010044310002,100331200141014,130000420243230,100232104120201,110112204224100,102212234021233,110224102230230,100120411200320], + 1003040010110001: [100032401030200,100021420120102,100014014210044,100022214101010,112434200202302,100310410140021,102001000221230,103221100211210,112400040102210,111110244102101], + 1003020101210132: [114444244144110,114201004110120,114033234032101,100412114304000,103001020120202,101004411032102,101000020302400,102021014012210,102244221114031,112400000200011], + 1140002103000201: [102001130220001,101410211021400,100004214100234,103000011400001,102104241412223,102002421442002,111131214422402,103100000210002,100000004200324,100013001031000], + 130122010311204: [102030111100022,102120000310301,100200040430313,100010021220004,112040021112102,100010000000131,101034124001203,100000311031000,100220124220140,100011101020000], + 321330000144224: [101000004210011,111230342220010,114010024011000,102000101410201,100004111024200,103302100140200,121103000144034,100211044311141,100111104002300,103002011432010], + 120221230002203: [111222202220021,111432124443120,103423201200020,110332111334020,111042000000020,110000001012000], + 132002410000033: [110243234240200,101301014221122,114110200212210,102041220200010,102130000312121,100400122201222,110231210001113,110012130410040,103210034021301,100104101200201], + 101101010210344: [110201201211024,110202000000310,110000010120043,100422314300200,102403404004110,102141410230020,110020001224021,101110020013040,101012410301010,112100000200031], + 202300121000400: [110320414420310,110100100101041,100420124100211,103010211222002,101040120320230,110013021300010,101043234000412,101220000040002,100422001002123,114010010010002], + 222100300214200: [110223010013204,102230400202000,100000121040140,102241330244410,100330041000221,100342011001201,114102100034220,100044000103202,102023020203230,114110200004041], + 1100013000421002: [103100030100010,102013110201200,100042000102010,112000230220102,102013000202010,100200001210240,112010022302321,101040224003400,102304111101041,103204101402321], + 103000012020402: [100404000022030,102301121100200,111131004101000,102010300200001,113003022402221,114400242311000,102201102021043], + 1000201230301400: [100021104340400,100003000410404,100230404343341,102002301442023,114200322333401,102403001400101,112000134002211,100000001020020,101221022120042,102034200222010], + 1023410200200310: [100040300102020,100012230204000,110131214220303,110143101120300,101101200311102,112401402023020,103142104001331,100200204123011,100301400040120,103031120143010], + 1102103311313110: [100000201020000,102030024112031,102401011401222,100002002212000,102114341341012,111420200002021,103421124042304,104000102100004,104021021224211,100100134300302], + 120200232204041: [111441300003100,111211414134201,114200044000012,100140101203122,101000121143120,100411310430002,112401102010230,111003000021043,101020030300010,102242011301200], + 133101010301002: [110101231202300,102023324010020,100130444102110,114000004103003,100001204342232,111131002212014,103010304012101,102210044010110,112000404000001,112000001121002], + 1002032043002014: [100004101032202,112100002011214,114401022311200,114020004020300,110114130114210,100004321021120,102300420220003,101400211012100,110012112003243,102104000213123], + 210300102002144: [104244002023000,120133001040211,112200431102021,111320124130040,110000110000231,100142041012023,110000000411120,110302100010342,101301030313022,111440222100012], + 1000100104404124: [112213000200301,100003224334120,100404224300012,110204130004030,110202120003032,100322004314021,102022010220223,100404000020012,102343301100440,102410434000220], + 1042412021024000: [101240220300022,103011431401300,100022000410041,102040300241403,103020000102011,100013011020311,114021004100210,103000310100320,102103331400000,101040421033204], + 1421000230400442: [102200004120034,101000024002230,111001200003214,102100021410210,110012020021204,101001420312100,100022201044101,102200010204000,100031000413030,100130241010201], + 1404022130033110: [114032104100141,101213114040141,102210101002412,111140100011101,110122421241103,112001144002010,101013030304101,100012011022000,102000004000013,100002021033103], + 1210000442011122: [100000044240301,101140021101302,111120224100101,114440120000030,101023041001203,100211400140102,101010040320111,103023101420104,114300014030021,114000010041302], + 1040120310344430: [100004214303020,131001224202110,100100400113040,131100001014001,102211122121042,114020420021403,111000014110301,110000012130411,102213244002203,114340224031221], + 1001130310002130: [102001404012100,102340120222440,102122214131011,114223204100010,111041202200140,100023031000024,111300400002313,100023014313010,114021040010311,100020004101012], + 1020001131220331: [100020331001310,100402010022123,110200131102200,100430204220020,104110241240001,110011242202000,102201012022300,110000421302031,112131442302432,103202111411203], + 1040212410000200: [101033101002303,102001104010010,112002030210041,110002102003311,100041130040040,111000030042302,111013004412334,110402410002301,110023032002000,101201010301001], + 1111013232224020: [103011041410132,100102134031030,110233000100021,100112104301200,100021242211014,101001210201440,101110040002210,110211104432213,111401304441341], + 1000010210231030: [103114204002100,100112011040011,100401024300321,114230004110101,102101004022104,101232104042101,100001101033010,100000201022420,103000011403101,100100014302013], + 1100010300003000: [111121100010021,110310034424102,102101211410144,100024201030210,102010111102410,101000110322242,110100001014311,102404110230202,110043400012000,100010020101222], + 304410010232404: [100114004100001,114102300004024,112102201102030,103222244003021,102420011111224,100340114211043,110232020002221,100033001220020,101100120334014,114233002340141], + 1020040001002013: [100214104301120,101002000321201,114300014030310,100130004300103,100040004331010,102320234112041,112420030202242,101001424004240,112321101102000,101401201013110], + 1102020022034142: [110400010001201,112012002002332,110412010002312,101004414000144,100143221000221,102000214001143,100312104100320,101002224000124,101022110304020,100104104002111], + 240012020420010: [110013030403023,103010204010010,112003002030002,110401231001202,101031211140304,114230110212040,100000034301140,102111011142022,114132142312022,111210404410344], + 140132113010222: [110330400010040,100101231004020,110010100022010,111000100012002,110022140120012,100143040411011,102404404004104,114002202302000,100034000000002,100400100031022], + 100301020102120: [110202102121414,100110014103210,100041204331000,114012032240012,102130004002131,110143020121321,101413001100003,110130020003201,102414231403301,101402211011032], + 1031020022320001: [102021001132040,110200400000020,100032201024101,110203131211112,102301004110004,110402420402001,110000112100402,100002204340200,111140000000000,110020041310021], + 1102000101201030: [103124001420200,100220210034042,102401001110000,112011300223041,102002001133122,100204011000221,100040020103014,100000201032240,102031010200002,101240204232402], + 1120222011041100: [101321001000010,101010424210144,102203011120021,100130014300042,114034400040402,100010100102032,112010344023013,114002002300222,102104000210330,101401300301000], + 110010000102200: [110102401201204,100222004320102,100110004103122,102200130202201,103020200141000,102414034040100,100212030414010,100000111034100,103132114002002,100412200002013], + 1000202000424040: [112102202040000,110100104404110,102110042001043,114100002204212,102003000212104,102000100220240,102030204000041,102110021341014,100210120430200,110203221112042], + 1023200020002101: [102010011411233,114004322320200,101030114211022,100403220020024,110033124420110,103102100122414,100121034230014,114322002322044,112040200210223,112002142310023], + 1021000100401030: [114000222211300,102130040230200,114030034013200,102303214031001,100001010101032,102212241110430,101124314020402,110130402140002,114432002322240,101402104020302], + 100113200442214: [103310001400000,110042014203200,100033304311022,111001210040344,100122401023041,100131014232113,100221000430010,100400302201222,110204020000322,101104301110011], + 1020310211300232: [110441234224400,103100014031411,110000300424304,100032121024110,110013122130200,114020204102020,103121221400012,102022400211311,110030400004330,102004204001111], + 122011330001240: [103000004012003,112303041103203,102101024022111,102020231440400,102144200210031,114030304122412,102121104130242,114104220000003,100112011040312,101013200321014], + 1044033110002024: [102010244010000,114430412322343,114200034110031,100000430014301,114423002314000,114040002210432,102214020242110,114010134021022,100010040122204,103314044033003], + 1103102304021202: [110000222102001,114400012323303,100100400412043,111000000020420,114320132322101,114320010000123,100021044312310,113200212430221,100010020023102,100000210000040], + 200231242112001: [102202310203222,114404010003320,100042001020203,114130210231020,112114324040000,100004410120102,111222214101043,101011211003002,100000241000002,101001040304214], + 200331011000030: [100100331000022,114222040214020,102000111441024,114240000000041,102032000223300,101013024000102,101000441140230,111300214121201,100100030402001,102400400200100], + 1022000100401212: [110010302000004,110410000104042,100014014203233,111422100034314,100102001013034,100000040413000,102030414003000,101342020314000,121310232003222,141000013100220], + 1001041002002004: [110002302010012,101212001204031,112100232040011,100132034104220,112032410212442,110021233042220,102002200222041,102404414041110,102144044001000,101013211000001], + 221102021000012: [100000430122100,101200100304010,100000001033001,102020200220310,100124100031200,101010200321022,102000231122032,103304014010000,114020002212200,112402002010210], + 1004212300002131: [114000024100022,101022004214304,101001231032003,100043420411130,101001020322010,114112244122013,103310220113140,112144232304210,102443421400110,100043041020120], + 240012400200230: [100140200020242,100004120021240,111201022223123,100131101201030,110001020030002,111421014442003,100100244002230,101010001000241,102000221100240,110120014401401], + 302210220143200: [102123220230210,101110004021320,102201230200104,103012101401220,103001334010240,100214324104012,101333201002122,103200021404423,102003114002001,102013010220212], + 1102200224120041: [114012304010103,101232404040100,100044000201201,103320304021024,102102020203131,100000301041003,114401322310000,101110404001000,100000000101012,100043204100144], + 121014100100044: [100020011041102,103022004000010,112110201100113,100412131010010,100130024000300,101411201111042,112122234040200,114122100211000,101101001110221,102302400213001], + 1013221232224201: [100203321001221,102310400244210,112111040230130,100004101023023,103010041241404,110333010011034,110423301004320,114000300011121,110401321340320,101110140302324], + 1121100201201012: [110202032123210,111122004100020,110412244220110,102411314024401,114001002300430,110101230100001,102200034024120,104102130014402,110314042102142,111120122242010], + 141021101412421: [111302020010000,114213222330042,101300221003002,104100212101311,100000121020303,102403004020102,110200220010220,101000001001114,103303021404201,100020010420242], + 1040412113004002: [100014100100001,102100004130301,111120004100414,102201101122100,101034024000101,103340410140122,100102114100420,111012202111021,100103144302200,101414100300221], + 1123140233130000: [100121230031032,112000431120410,103042024040104,102304104110001,100104211044110,114241222321321,114021002302020,114013124030022,100013200100011,114104200220022], + 110020043303032: [100024000110221,114130014001202,110010220103020,111004100022110,114040210022000,111001344400222,101021204010011,100404410022320,103012101410102,111000000000411], + 220141021000201: [110442104221030,101224001202324,103102134001111,102011310202304,100002301040000,112000132001414,111124402243200,102001331441012,100203014121400,110042002002040], + 121044040131204: [102133011413110,111001200041102,114022424102243,101223020300040,103111420110210,102034324000220,102022400203211,101230020303000,111340130010314,101214240300041], + 223222211002011: [110040102001121,110200321303322,114032024012040,103002041402004,102103030210003,103010011401200,114121134124014,103013224034023,100020014210002,100001421042312], + 1010002004220233: [100004101032202,112100002011214,114401022311200,114020004020300,102420400200000,110114130114210,104200200001200,100004321021120,140243003020120,100003040102022], + 100002100000004: [111030212113431,110001030120020,103222004032000,102233034000002,112130004021000,100100200021431,112101202012010,111212024101031,101013040300032,102112314002011], + 100000201101100: [103012034041202,100100204100022,103130031241103,103234031200401,114011320024214,100233001000010,110322311300120,100204431000210,112100204000103,110022040140021], + 1022102240321112: [103034010121101,102302200210010,102340120222440,114223204100010,111041202200140,111300400002313,100023014313010,114021040010311,114140004123122,100002301021040], + 121312113301020: [112311011101001,100210201001001,101100001101401,110100124402042,111120402212201,100101021021114,102120404134413,100210010430242,101411001011011,110040212000010], + 133122111020100: [110021000410432,100042304102210,100013030100002,101010010320112,112000021122010,100021111043012,110124041140000,100010044101002,100001000100403,100020124100010], + 230330000200020: [114002104014300,102000311102212,102010004040000,112433112020200,102231041120104,114132420004104,114100110220013,101431304024200,103004021430003,100040404202000], + 1420420332402401: [100232214222204,100040324331403,112104212010101,100001104201201,102300221002020,100002101020010,112010202000202,102033024010010,100004001000211,114230112330402], + 130022024022302: [101001400301113,103101024004200,103024000103302,103300021402104,102014111102023,102102024000001,101301014220002,101012044004042,112410300200001,102020304000321], + 220002202343040: [102114340204022,101000011030111,1303043020124234,114403402311003,111143400421100,110221310000130,100223331020012,120313211020000,1013001120112020,1311314200100310], + 1143000013403000: [101020204214020,100131144232400,101001004220021,110232241101002,102104101340430,111333020000020,112233010221200,114020020001014,102201401001104,101003200300401], + 231323022320340: [110202004211120,110223224433004,110341010044330,102031144010424,100302420120212,111212114131222,102140001441301,102223400201104,102342120222031,102221010201113], + 212311220313403: [103300121401234,100122200020013,100004004210020,102331104112002,110121112010004,114132002200241,102330144110211,100404000020300,110214202124100,101200004233120], + 120040001042420: [114343002322014,114100022342130,100013024312024,111012002200101,102102211140013,110020220022010,110210020002243,110121220000022,103400100130300,112400434040004], + 1420010032000210: [110000212101040,110301011234204,110021410020203,111120002100412,103330421400224,112024232302040,114013022304040,101023410321122,102021311100042,111000304400311], + 240402440400100: [110111032140220,100023101042010,102112310210202,102330010243440,114042044100403,114221224002403,100013310123100,100022410101442,114200022343003,100024101022010], + 111100013020240: [101000201031101,131204100021112,113003221014312,103440324001431,123400040222113,103102104003010,132220204100102,131202200011113,102044400022000,112120140231000], + 1004040110002100: [101221121202421,110020102000133,100000204342022,100001020012120,111042022141200,101441101010020,100100241020020,100002004342004,103010330100320,110113042000320], + 1120212202100110: [112342210200100,101021020331240,100020400003003,114100234000201], + 100000000140300: [100002100100210,102420424042020,100010001032223,103020031403100,102200401111200,102000430221040,114003104031111,100100000422320,100102020411200,102100012002000], + 102301020111410: [101022014222024,110100120400020,100032000101014,114000024101202,111311002224001,114030000030012,100032134101100,112010024023002,114231032340010,100000010202201], + 200000200033000: [114343002322014,100022314100104,102130314131401,114100022342130,114300010002100,100013024312024,102002020243020,114002002300201,102040021121030,102102211140013], + 1001304001303142: [100000431020101,100244100032320,110010212101240,104104001243020,100032040000331,104124102100301,110002010440412,110111420033313,100201310000404,103100200103020], + 241003123120040: [100422040021304,102000024011300,100021320123031,100014041042003,100002010413410,101011210300000,101433010300204,102114321401000,100002414201103,101002221140440], + 130210200223122: [102020314012030,101002100323042,114110000002010,102110300210002,100010200101222,114004000020012,101031001032010,114442102310324,102324400243001,100440000030010], + 121021240400431: [101043224001442,110041100141020,101001004002100,110300214430000,110002001220310,111331104131204,101040204002221,112200004001330,102300121100001,110421102110004], + 141422230020000: [102230004030112,100100221012100,1002022012411300,214021333002200,112102000202302,103013200104400,100130401022113,112001421111242,1011001024420302,114112402340003], + 1110103102004001: [103204424022010,110304304420001,102110402001413,102131334020220,114210024001201,1031024222000122,200003020011141,100020111230000,114102010224000,114301012300202], + 200000010033000: [111320012221132,102302144110440,102143202000400,111020002202333,111130224102101,101321311004010,102110241342210,100002320411400,114201000004122,100143034304100], + 1102030130400422: [100000044301222,111012034402110,114221004034110,111100104104202,101223041020020,102002204000124,100011230120014,101104024002242,110133120011001,100400010013033], + 103242023022021: [100013400423030,100033100421220,100032221044041,112210034000434,110131142113202,100030011041024,100011114313403,111010234110022], + 213010221032130: [114410024110002,111200210001023,101101401020424,114030220011120,100002200100100,112410110201010,100020000120134,112422100200404,110202001212002,110001014204010], + 1022203112204104: [102000101130132,100402412200004,112040100210110,111201210000411,102204311100014,110213331312003], + 103324010102300: [110114001202122,103034031400131,100001010100220,114002114012041,102000004012011,110101100012002,110001002004240,103322000112244,100030220002102,111010024401332], + 1030020201140321: [100032004200002,100020241021124,112342201131331,100010200414111,100121044230002,112003442002011,110010022132422,111000042200101,110043130440321,100244341003000], + 1000112000102220: [100400210010032,110022030110040,102011211321000,102124210200120,112112004042000,110010144200414,102010112000301,101023324003111,102330021000022,100000021221004], + 140131110100120: [102231102020200,102120201140110,100331200141014,110112204224100,100200011002042,102212234021233,110224102230230,100120411200320,112401344040043], + 240420400202110: [102212300202110,100012120201211,100024414212001,100000014310020,100022204300002,101014014211233,100412120433120,101010100312002], + 1012000100224014: [112003001133011,101002240304011,100201134100140,110034100040021,102000221032102,110213002132000,103010000110210,102022201020004,100100424030003,101000131030120], + 1014301024113321: [110212012114431,100001140020000,100012101223021,110031301200114,114002020044120,100021004302202,102202200240222,114102010220042,102021301441201,104103102103201], + 1000200001222201: [110003000042343,100020341001100,110110414402000,101100001100404,110011000043131,100121214300203,100022221044012,110312300010200,110001120021021,1020110000101002], + 302000010323001: [102143124001400,100011011020440,101002121000111,114023314013200,100000201024213,114003422304142,111001404112102,102010201122000,114011042300202,101400031014311], + 213000402300202: [102142221342202,103043404000202,102420000202033,101012400343401,100020101020404,100002411021201,102110010210330,100012020410400,111111102240001,102122111402420], + 114002013020030: [110101210013000,100404121014002,101240220300022,110120020002304,100011000202214,100000024100000,110212214400114,110012101102100,102102304001200,100010040001210], + 1104000001201040: [103142021211011,313040122221220,102121030212020,114411024142133,103004201240410,100022024340200,110230142122333,110010002002000,110204012111004,112311411133302], + 111001000401004: [110002212130403,101042411000122,114101002311013,100133004000124,112440104042121,114200124000134,100224210432130,100120204234213,100003011231420,100222200002003], + 100021020102200: [100113220020101,114031000022030,102014002000401,103103241421322,114121012340044,102104304023201,103310300140324,100002224244002,114310200002400,103211220100010], + 1003012121103120: [110332202020000,112421004012141,102224410201003,110030021010001,112001321113132,114224034000310,102332101001000,114002100024002,114424214144024,103101440121101], + 210212004000200: [110002420020000,100002210401034,112011340213224,101013011030413,111301042202102,101421041100223,102000111122140,100001210000030,101034231002130,114220204031100], + 1031042010002130: [102004004002321,102001010240202,111301022200213,110310012024144,114213002341424,112031000230000,112012240221124,100440310030003,102344100222410,110431020000020], + 1041440213142030: [102301401002404,100232214222204,102012004010000,100040324331403,112104212010101,100001104201201,102300221002020,100002101020010,112010202000202,102033024010010], + 110310001230122: [102311004012010,101020401033332,100012001023022,102112012004120,111321000002001,101210011042021,100042100003104,100004020021344,112420044040112,100100000000042], + 1002022011231114: [100030010422041,114003014100103,112421112010232,102010420200220,112234001100044,102033001100221,100210144220030,100001410012241,101003004000010,101001011002301], + 100041031024132: [102201444044432,114111140220220,114004100011010,114302010000013,100100124003241,100002310120001,100111014231402,110220022111241,114100404000100,100022024100312], + 1100111000121110: [100200011002200,112001112002104,113134002412222,102100311320110,110430002112002,102240030230010,110030010120002,110242024430440,111003212230033,111020404402004], + 100004331000314: [100002044211310,110430122111140,104012302104014,102320221000230,1323100312100112,242022202122014,103014004000240,1140000400200300,101141224002302,111101144404022], + 101014020002002: [114020000020001,1302101004142102,110001001100001,201014000241421,110400102312140,114223013001001,1002000010441103,100111204004442,1300011022000001,401400200400300], + 114000140411200: [111110232242220,100121104300001,110002041102000,103032040110110,100110001201401,112000042002001,100200130430232,103022101412303,103011044000000,100101124002120], + 233020400311200: [110414402020021,101000034000220,114312012300300,101012104210042,101430001010032,112402012020000,103322241400404,103210120100143,101010024213100,100040000123130], + 1124242430341002: [114400214140002,114024022241001,111342314121314,100102014230000,103410004001234,100402022200304,102242024030234,114012434103044,110001001320030,114222010210204], + 111202040214200: [100240000032004,102000000210211,111010204401023,103142444002002,101200010300001,102211300204221,114420232314210,100301004321221,100020000410313,101220200040320], + 103312000220111: [102141401343022,114131304142010,102110314002123,101100020300101,100111121000000,111131124100300,101020204010401,102040111124412,102113100203200,112310231134114], + 1020111021110122: [102343230224321,102112231020231,102320000240102,100042144200000,114201104111034,102310140240012,102030304001101,100020420121003,103020004011414,102102201340311], + 1013402100221003: [100000014102130,100022044344000,140104013031303,101101001020004,110010404413302,100011144312002,110004001104031,100013001214140,110002000040202,110110424221134], + 100002202300342: [102021001132040,110201201211024,110402420402001,110021021210300,110404000000012,102000101120123,110221022101104,110023100402320,100020311220412,110123004401121], + 101322213042004: [114024312212020,103104001440422,114220302314020,112030101110231,103200024030232,111014024112203,102013434000000,101102411114421,110000020042112,110231004242101], + 1022004104121240: [111400124420002,110020402002000,101033124000402,102401000201121,103310421404111,103000020120303,111013232200403,100112044024030,101202024231020,114100042311200], + 1041110400020423: [100200024104410,104100402102320,104133012103021,102200011100420,110020231100021,102102304004203,104132311242210,101040210312111,102210244040143,101100224000200], + 130033111010012: [103012011434022,114103402201140,101313004232122,100001004301400,100031001020001,102111420210110,102104131414203,102203314011321,102000204001042,101231220300123], + 103012141104024: [102113300230021,100010044310002,130000420243230,100232104120201,114221000004311], + 1240030323000021: [114031022302044,102031011441221,102021201410011,114103020221100,102002024000132,100401001011010,100212221002300,102400004021004,102240021302000,103202140103403], + 1143132040003030: [114030110041300,103112004030003,102300001002144,103132424000410,112013102004422,100400220013232,110010002000100], + 1010001102001304: [114343002322014,100022314100104,102130314131401,114100022342130,114300010002100,100013024312024,114002002300201,111012002200101,102102211140013,100311314310000], + 212130202420022: [100313030142202,101221020300020,102013401100100,112210102030020,102043030202102,102300014110023,114230024111000,100402120031033,102103422004103,100010024202200], + 101014002002031: [112000001123004,103400100131022,101004141000312,100010014313003,114100212210001,100022230100202,110100020004310,114143200211211,102002001101211,110112022120231], + 240100123042024: [101042104010000,114000122301411,102111002001230,110410000002004,111424002101030,100414231011020,114121110030203,100110044301024,111100040001003,100042404100401], + 1424233242210312: [102041310200042,110320202023400,111431110000042,110301030010140,102004441124110,103303201400021,114101420030202,114421242204443,100000301221024,101224322120022], + 311001100230040: [114040102210432,100034004211240,102140121410131,112040200233002,102113111343110,103234100101221,114002220010031,103103311424020,101030010320024,100001010412000], + 122322003230020: [110141104201032,103200000101342,100021000101421,102103034000310,110011042100122,102001231131043,112000000212221,143304200441210,101022134002430,112031020230410], + 1000020340012002: [112124004022322,111300210014020,102103201320411,100100031043410,101033214211000,114001100024243,114100012204104,110141112044000,100034244303010,102003104000032], + 1000002031024030: [110202012100020,102303010241010,111342020011220,102230130203001,102021401324232,111222102243400,101004410311232,101201034010420,111220410010144,100001221021031], + 121212143303410: [104130242103012,100002131024210,102000101132400,102412101112121,112023140212112,112313301100030,102110244000130,102101031412121,102313310224103,114000312301300], + 1012030100120121: [102301004011202,102000201100400,110034120023130,102101004002000,100110010410230,112121040200102,103000101240211,114221040210200,100134044003303,110220010010120], + 102303023001302: [100032041021210,110004301222000,110414300030001,100030020011022,114310000001232,111202012222402,102040041320010,103203401400132,103142111441040,110104002010100], + 1000100140043210: [114443330001442,103101041421200,102222321000301,102040244010100,101204444040122,114031030041040,102114240204013,112104222012023,102031021133300,100011301043341], + 1000000230032042: [110102224201130,102104131412412,114020312300021,102400204043012,100000000200102,101011011000320,114420200001202,102100200233123,101012421000011,114023004031001], + 224400120211044: [100002030102221,110414000032411,100120301022212,112203100201021,110000142000203,100013220400031,100200000430401,112203424001001,110310322100124,114000010010203], + 1010240040002121: [102040431121110,101221020040220,114111100021420,112024212301420,102212000200124,100300310140241,100240134323001,100103104302044,102141212000200,102042000222002], + 1400101021431000: [102000001132113,102202310203222,100042001020203,102002320220202,100010044300003,114130210231020,100004410120102,111222214101043,114412142320040,102100044000000], + 101310324040001: [102011201101012,102300304110030,114412000003141,114120430002002,103020041420212,100112011040011,114033300041020,101201220300012,100401024300321,100102030423010], + 110013423010002: [101041310301004,110021122100000,103001224014142,114431224113420,114033012202420,111211002241330,102012000213011,112040004000012,112410214043412,102113201401300], + 1100423401003000: [100004221020020,100013214101120,103321300144024,103241114031030,100143001000202,112040222001200,102010304012020,103131032021030,100004124302203,110200231314311], + 101000020211200: [103111401420301,110124010031144,102140230210111,100011210412002,112004431132202,114130202311020,112120402013111,100434444323300,110230112032040,114031400042021], + 120011030120000: [110204034240010,104102030012121,110000011100204,102110231441040,101021111000022,102100111413012,100113214302002,103442014000100,103021000144000,103132014002131], + 1032020012230112: [110230000000002,110220301202400,100004414101224,101003140322000,110401001002400,102002001130001,103012000100400,114201142324042,102213401111223,100040120000031], + 1110112230110132: [102323304112342,114003222201103,110240020100212,100022204300000,112012211120102,100101040400110,114221002340120,101002204001310,114220200000002,102324004112400], + 1002112332100123: [110301011234204,114211102321011,103330421400224,102000200201422,102412004022002,103220124034124,100032204200023,100023211030203,102104301004310,112000132302101], + 1040000021224110: [114040100030400,102301011002321,101012011022300,110003301213002,103412224020402,112033311122000,100210001002210,102110120202141,114241032332313,112120201101200], + 101122020023011: [103122114004113,102242301122200,110030110122402,101344140314114,102100201400122,100011111022300,114032300011302,100234004033234,101222221020440,100230020410200], + 121012011002001: [101210144014403,102111420233012,110000020022324,100020231201012,102210424042300,100101101020002,110030420410024,111002012202324,402104002030100,101032040320334], + 1004000430310231: [110213002132000,100311221002322,102022420220121,102401214020202,112102204024002,101000131030120,100001301214030,111140000012120,100410040430220,101041404002020], + 1021311102043111: [104110212100123,101200140044000,102214014010030,100021230411014,110024000412302,102331104110040,100002134300030,100130414300000,112310002020302,102002201413004], + 240011130320214: [101042411000122,112041402312040,103023021244000,110104434402221,100224210432130,101002024012004,101421210302410,112030022300112,103100020122200,110241130013040], + 133402201020122: [103140014002031,112003020220120,100043024210301,102014001130100,103400201200000,114021200012000,102422131400024,103210304000030,102340101000041,111201000013222], + 300134100002212: [110224314430000,102203301123001,103100134001001,103210400110122,114030314123101,101201124013202,111322012202310,100400201010000,100010321043134,111220020010043], + 300010200313412: [110202210102120,114001004100003,100041014102004,110320022101120,102131421000411,101412030302001,102222021124112,114000040031021,102400001110113,100404201012020], + 1030111104004221: [111220204101421,110042120021013,112200420200200,101001010300011,114012020044224,102122401340101,110021020001220,112001024000200,110112030401012,112020012002031], + 100341200042220: [110000202003120,100130220400000,102312300220000,112221024002232,101020111140040,102041111130300,101042200303012,110401202021231,100240204101020,113020012400412], + 133102000010222: [111130224102101,102322020212020,114403304140021,102103021340120,100031131042030,112201422040000,114021040001000,114024130031020,101220201000030,114022300011000], + 130044324004400: [102303110220130,100124120011100,114003004031430,100220304220004,114110000214110,113004001021230,102411000200112,110332432020400,100120120402022,112110322044020], + 124021132014040: [114021000012310,101042410301221,110432300102000,100011004102400,102304000210204,110040344210011,100020120101000,100003200020112,100400231000200,112143144020012], + 141004020022004: [104140321242022,110020004422304,110310000104014,103204301200000,110122022041331,103010311410024,103403411212300,111102412112040,102230002023220,103012041241100], + 223001001300404: [102000140200220,114233210000201,100002001024100,102103130221330,110011002100114,114102220033034,114004020020313,102022421132024,103303041402240,100002121021022], + 101211101320010: [110202004211120,110223224433004,110341010044330,102031144010424,100302420120212,114004142244000,111212114131222,102140001441301,111012030022123,110000011220204], + 1003120112012004: [103220000100202,103122224034122,100142011002402,114004200021000,101302331000221,101111440324120,102302221002020,102101114000401,110102002120401,102124301120200], + 1114204043000300: [110312332102012,101404204001310,101003100302100,103000331422023,101400101100001,100100020401310,101040234210040,102003424021402,110021330033102,101002034003411], + 1120100200003322: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 1124101002002300: [102001404012100,112004202302034,103300004021200,102122214131011,100023031000024,103230134011412,100020004101012,102402000201011,102311011000200,102021021101204], + 123002100034100: [102422001400000,100301224310100,103002104012101,103220130211414,101020220323012,100012324202240,112101102012030,110003410100312,114000022300301,114000000021100], + 1003011202213222: [101011004212201,110032022002020,100214230430124,103031234000122,103230011412301,101042001021012,101100104002023,100400000010020,100124021201021,100102001000000], + 100130000013301: [114020024120310,121021032342113,110220210110004,1122204031101014,100003204214031,1100220200041014], + 1001121021323132: [110112102211042,114200022300033,101400220303133,110431442110400,114011120021012,100100111041320,101420010300310,110000004210112,102334001004100,104100001240034], + 1012100044011013: [111101010010203,110110212010011,103120101441202,110011000022102,101002121003112,100004104210221,102202410240103,400014404414011,100030211040004,100000010101402], + 133020140000230: [111102110012000,101001400301113,103101024004200,101000344010212,103300021402104,102100431342023,102102024000001,100104400021023,114003104032034,102020304000321], + 1140232120001101: [102000144014000,102100104002302,102120010230031,111202300010010,102020304000242,101232321020000,110002400023342,100120044233220,103402201212100,113031010134002], + 132103142201004: [102300324010203,102100142002204,102040011121100,110113004402201,100030024303023,102042204000300,100001134100120,114023214101310,110301232000100,110102400013020], + 1100412112100411: [100041200010000,110111001300044,111000002202324,104132100011024,111211010001300,100113434301241,114030020020301,111014014401303,103210001422303,100100000022131], + 124031212031103: [102110104004031,110130100010331,114004004100022,142100000024013,110022000022202,114300402320043,103110214004242,120002222420113,110404044220000,101010211033230], + 1140002323210032: [114000102240100,103200021401030,230222010240012,112102121020220,130300100333301,100020120024010,112042042001002,114102002344100,100011204340230,100202400002411], + 1141001143204003: [103210400110122,101112020300011,114104302341000,100400201010000,100010321043134,111220020010043,102100021342024,102244400201444,101010001000121,101232104040130], + 1030021010204101: [102020044000030,100002001022412,111202320012012,100003001020010,102442004020131,101011124210300,112101422301001,101301220311200,110040014213300,100320421002220], + 1020112001300220: [102000020223013,114040102301100,112121032014014,102310111001210,100020241043022,114413232320000,100100001040134,102100121341102,100002004130101,100301024310020], + 110100401302202: [100103200020313,110000431213211,100414024102342,101120120330222], + 1003232100422034: [110104231221040,100042110122000,114400322311044,101021021002110,103224401422304,112112122012022,100401140033104,102120100212020,100020114200220,102411130201102], + 1004201300020013: [100001300102001,100220101204311,112033124022002,101013114001130,110022134210202,110110102042312,110440211340302,100001300000022,101004104010020,102001014003100], + 102012021000021: [111101122102222,110034004420011,103000114001000,102242024030234,110141201000200,100003344214000,114400300000221,110314014422011,111022214113044,103104024000023], + 243300413202000: [110041030411301,110001041213031,103301210142043,101110044200100,102411000200000,110414300030001,100030020011022,100400014321101,114100122342002,111202012222402], + 243103020000241: [110020402002000,102042221101230,101033124000402,103310421404111,102101134004010,103000020120303,100112044024030,103240100102101,101202024231020,114100042311200], + 224044330400040: [103102101422031,102130124130100,112404002023002,102022020204430,103214021400010,114003422304142,100012401020212,110100022010014,102042231130200,103144220102102], + 110124302311002: [102010011411233,101030114211022,110033124420110,112002142310023,100040101020201,102102240210310,114231220004002,112020300241320,110410012020110,100004424230021], + 1100013010001240: [111020044112020,102004404000111,100020040101021,110100312012040,101104312040120,114044400021021,111412122101012,100003200100331,100000124200111,112220434011000], + 130010402030010: [111102440020002,101202001024340,100004000102302,103312010113222,110130022140122,112002304004203,100034110413403,101030040320021,114104000002301,102232110201100], + 1000102120101030: [103442110132330,102111310313001,100203010434220,102140322001242,114023044020211,112013124020300,102202321114004,110401214221203,200200133341004,100242001200000], + 1141200320010130: [114213002340022,101400104042212,100000021022400,144200203310100,1003022312322100,102001244001224,114030214020000,102023422000000,120101041020020,102330204110410], + 1010204301300213: [110200400000020,110203131211112,102301004110004,110021100023210,103122000100403,100002204340200,114103412201420,111140000000000,110014300041302,110020041310021], + 200340341310214: [102130124130100,101002121000111,100000201024213,102022020204430,114003422304142,100012401020212,111001404112102,101400031014311,102110230200201,101240404011020], + 310020203111444: [114120030223400,114423312314004,100340100424220,101202014010412,102144031403200,100041004202111,342003122142040,100243404101011,110421104220200,102322124112422], + 1000221100000124: [100000410103200,100001240410410,101042201000011,102030001412241,101001204010220,100004301023143,114223200221140,101012400304201,100031044300340,112004021121002], + 120242012440140: [100111334330000,110023240021020,100300433210004,102240100011000,100400213242110,100020201002004,120021202100230,102320120240200,100000012221111,110102301010411], + 1140023440311401: [100430211011410,110010340040012,111010124402202,110211020121140,100020244310231,101000030321102,102110320210011,114221234002100,100033100101240,102420001110301], + 212102030132222: [103312010113213,110020240022142,114401212310021,110131022111320,112000401132020,111302014120120,110013034211021,103001214042003,101020241021030,110020001300000], + 140241400202022: [103010021422042,101110000010122,102100404000021,110323002022000,104123302100200,100103414300020,110010121333141,102402034020001,111202324134000,101433201010200], + 130002021100101: [103003001400110,102143011343003,112022001120410,100341410422102,111002012200131,101400040330021,112210001102424,110101321301120,110001032002011,114102012344003], + 1000300014100040: [101020044011003,100021014100124,100122040012210,101040000300110,114202124000200,112041432030144,114000120020004,114241110000102,102140214001144,110200202121001], + 1142021241010010: [103000011402201,110210134244100,102121041441000,114102022200000,110233010002020,111203034103022,102101304000012,114020202241323,110004402131000,102132421000100], + 1121140022033000: [100121230031032,112000431120410,103042024040104,102304104110001,102000200200301,100104211044110,110200101200402,101342300314204,114241222321321,114013124030022], + 124402000221041: [100000044204004,101020224210014,114202244101041,100122310020400,112423102010012,102112022001414,101212214011134,100001121023210,100012101020002,114204120000200], + 1040033030201302: [101230111024130,1112100200412130,1320100232411004,100121120102303,1020024112001010,120100010104132,423203002400042], + 210001020023030: [111102104100334,111210014102030,110401100001104,111440000000202,111200344442041,103141001240021,100001401034130,101220200304110,110420014242010,110403102222001], + 1101432000001304: [110230000000002,110220301202400,101003140322000,110401001002400,103012000100400,110210024220020,100401424300314,100040120000031,114200142324000,112100322040040], + 214414123000031: [104132340011314,114012040020310,103132004002242,110000212104130,110200200004002,114131040224332,100123020032031,121002023311103,100021124203441,102022411412401], + 1002100411213122: [100422000031421,101214104041040,110104231221040,100102000010243,112410034040040,103031410122401,103101000100022,100040021031201,103000300120001,100020141044111], + 1002400232420012: [102004300220000,102010212000134,102110021341422,114241022332104,101403020334021,100010001040104,110141020400341,114133102311014,102341204111304,103211001422023], + 144212103223430: [110011414240022,111142010020301,102100104000040,100000144104100,100010044300003,112120224040040,103301410110110,112114324040000,102124031023100,100204104320231], + 221340140432000: [101220111020012,111401200000040,102300122004231,101041204222101,100024024211001,102110001342114,102042444010014,102330311004110,114032110040320,111203012221030], + 202331013000002: [110100100031014,114001002300430,110411130100013,100021044210012,102212034044212,111341300011434,100401304302243,114101212202230,100420001001112,102140400210434], + 1000223001223311: [114041400010321,101002234002002,100000310102011,102220130204110,102331020242011,102012030220314,100244244322120,100220034341000,102101134030334,102103202002232], + 120022010300020: [101121211101004,101114101012020,101001304001101,103000110142041,102002112041034,102041111020030,110022001201023,103101124003110,112401144042000,101222044204000], + 1100030000444204: [110013202003320,101031241000010,102120231343224,110030332100203,114404232310120,103100034001310,114002202210331,100031301020100,110111032140220,100020010200022], + 222201234100023: [100002001013012,114120220214130,100002200001011,100120001204102], + 112310442004211: [111030124112220,110000230010221,110202110113000,100324114310222,114001020022140,110002242100100,114012004020230,110000104211010,101022221002220,110220400401033], + 130013314023140: [402000401204030,114124020222032,100140201000222,110110000004210,101400010303002,104200202141001,130030220200012,112200110000221,1321002023100013,1103040030102440], + 1010224102021001: [101240220300022,100011000202214,102200130202201,102002020220000,100102120422002,100002010014040,100001300012442,100022000410041,103020000102011,103001031420203], + 122430102020402: [220212211200433,110002144411414,100003024303000,101204110411102,102142302000411,103222440102000,102440420200031,110002241012102,100131100001021,100000100422002], + 204103001102322: [100440031001120,102020200223310,103220011420242,102032012000101,101001400301113,101004201001232,112102102302000,102141231343401,101231104200000,100002120200101], + 211130330201010: [101221414041100,100032424312011,101110301040312,102204010204023,103041020101400,111300402200003,114141024004011,110022341300320,100210301002021,103040000000212], + 1113002200100201: [110041030411301,110001041213031,101110044200100,102411000200000,110414300030001,100030020011022,114100122342002,111202012222402,110033041200104,102000221442214], + 1010010411302200: [101010241003223,102000020220000,114412142320040,100003044100101,114012402332300,102220211122102,114420022314022,102234004010003,110204314402021,103121004002210], + 1044002110020220: [100400224300040,111144042240304,102000131131100,110201002043201,102400021401101,102141201342300,102140210230000,102131211411102,101001004012413,102024244002012], + 1201222201213002: [100110000410200,110120200030233,100132040031022,102442004020131,110031010430100,100432431000310,100004000014032,101014121024142,101001201022304,102104004002400], + 1041121212311212: [102000221101002,102000431130020,103102314001204,103120004004010,103222120102031,111104404100200,114432224142000,100202234320210,102112400210210,114001332210232], + 100040011201012: [101230002122040,101210241204043,104102040011120,111311120014011,100123011004113,100420001002101,102430121110340,102020121102120,112141104020201,102000024000002], + 1100100120201300: [100301301000024,102020111324200,101044400300030,100100310024040,101024024002120,103212010100200,132224022200202,100231004331011,110203002102023,103442121212103], + 202310400211312: [114200212322001,100401210020002,112210322040121,100402042200000,110001440041003,100010111022102,100220300410430,101402010301000,100000220111021,103140120112001], + 101300043401010: [110101200032041,113402202420020,100000012212010,110041002000220,100040111030202,101142410330304,103110001242101,103431011210021,111132304100420,110433222223310], + 1120000022102114: [100321004011041,110002342100014,110021312002040,111101042244210,110441010002400,110124002040002,103110314000100,110023410122402,114203104001000,114302200014241], + 1002022101340120: [103203224022224,100143200421104,110213010400012,100123221201001,112313000202012,114022114010220,100010001043004,100011410400320,101112020330001,110102101002040], + 1020421022112102: [112010032340022,114120304000212,100141410402200,114111202313213,101042041021001,101211414040000,100010031232443,100242024100000,100114020414244,100012404203210], + 1400020342002003: [112012000220043,102414000203000,111101400022211,111320100000001,112002202000010,114001102301101,101010041003004,102000121442001,114011020020242,114030100040000], + 1021420024210010: [110431442110400,114011120021012,100100111041320,101420010300310,110000004210112,102334001004100,111321424123422,100004000002200,100001140411014,101312014234200], + 1410343201224101: [102242304042410,112032012004300,101001034002001,102000201131020,1010120030012200,101024411001024,221104221024023,100010410420002,102123332000002,112000034000041], + 1021212301002021: [114104200220022,102010244010000,114430412322343,100000430014301,114010134021022,114102224104002,100040240003341,114422404110312,112140134003231,102403144000120], + 111012320010012: [102000034011002,103204000110000,100001014340021,100000034312214,102103001340022,112032000211000,134402411001001,110032020020001,100002110000131,112021020220112], + 132234122213020: [103040014000114,110012040030401,111020142230010], + 1040111100100000: [111122010010414,102040404041112,114140030222402,103331304032010,100121311021322,112301120200041,111003302200334,101000200321321,102440000234100,103030100144420], + 1130210231004021: [120402022102021,114400210002021,102010002000402,114201402332241,114211030021301,210412232040000,114030214020000,114022000013011,111232232222210,102230104030012], + 1003220132012024: [100030204300220,101021334000222,114010122330030,100011024201101,111222442222413,110030122102303,103044001412002,102211124032000,110400200000240,110101301000001], + 1444200133302110: [100101024303332,100013201020230,112300101101010,114301302323032,114200304000002,1300040101002020,123310121130130,1001210043013022,143442111023013,1022003020311200], + 1022120000030130: [102040431121110,114111100021420,112024212301420,102212000200124,100300310140241,100240134323001,102042000222002,102001011100100,114402104142102,100030010102102], + 101000000200420: [110020301220324,103040020122332,102020100243032,102012200202303,101110404021211,103110041442122,114042014102321,112003110242131,102112222001200,100011114300032], + 1040030020032021: [101004200304221,111203102223243,114221334111220,100010034310013,114311400000224,100040101001132,112211132040204,102113232001100,101110044000400,102102021002000], + 1123032011000000: [111001000020034,112011041110422,101410014021040,110001032010100,102242210200010,114422214113202,1100020120011024,112411210202004,110002421122010,102001200200221], + 1024034310220010: [112413224040101,100220100110400,101200031020230,102403004042342,101024001034211,111122004101222,114020040013100,114001012300002,102121100232012,114000222213021], + 1120120243000100: [120101012430440,103102124000030,111000324110232,103402001200000,100400120022020,102120300203403,110323300004120,111102204403003,111401114423000,110010120020200], + 112100410221222: [110002004410202,102103114000024,101101410010023,112041002002124,140343100002103,400200234320200,101041200320322,100020124204330,110200320000000,100001424102041], + 1000100012210014: [103134014000340,104103100010141,101440004041120,111101222240010,100040210411102,101031214000041,100110004102034,114112020212203,102040140220220,114300132321233], + 1142300113030404: [100022041030000,102202000200010,100010430202422,112340020203003,102443011400041,100010430022021,103032441431121,111300030040030,111003000041302,112434400204320], + 1022042041011200: [111110214100223,100012000414010,101200020300410,100110224304220,102330211001002,114002110022030,112211110200310,102212141112000,100023020200332,114020204100242], + 121221003240413: [101211201202134,103120104030100,102020030220200,110100440400010,110003434410403,111110000014401,100000004130010,101300204230000,114002004100140,102311020240020], + 110300322300102: [102130411411444,103103204000110,100441301014410,102404004001203,114001024010010,102101224000013,111212204420203,114230020000033,101012004002440,103110400120002], + 131134004004000: [110110010022302,103000431240102,114011004114100,110101140002212,110420000104020,110410140000110,100000401031111,102004101410420,110204242124012,110022301301002], + 130232344011120: [110011011212100,101134030011000,103220211421421,110123230124040,131000001020102,100044130000101,110420001000202,100102110402220,110412310030001,114012022302022], + 122201020003224: [110441234224400,103100014031411,110000300424304,100032121024110,110013122130200,114020204102020,103121221400012,102022400211311,110030400004330,102004204001111], + 132444244300220: [102140014000020,103011020140013,110030002102021,112200401102102,110304200001120,110022042000121,111122104100001,110402324221020,102412021114100,102110004030420], + 100240020000010: [100001044201401,103022120100401,112411042012210,100110444302011,102142140210001,102000202041211,100211004220330,100000304104221,101002104004003,114124004001310], + 1023120202043100: [102104002004301,102144002001232,110000221223422,102002104001004,101440001104012,102441140234014,100411130430221,102344004014110,101120121103012,111032102202040], + 1004324022323001: [111000000010022,102040001123104,100210414104124,110403022010001,112110001103200,100204004123220,114300202300030,103401140121121,112100122010004,100100240010030], + 100230002202140: [104102202102142,100000401022041,101012310301211,101204234044003,122002011010101,103014134000300,112001002030020,112030200241011,112034002002000,114100202203044], + 1422202204201044: [100310304310342,100010041031020,100042400001023,112402000200101,100020201221000,101010020301243,111010130022401,112140214000020,101310000314110,100013111020021], + 101000000100031: [114210100002014,114440140000234,100021100420321,100400000020412,112230002033202,100401222201402,110000001012100,102101011123100,101440001100100,111210200002411], + 1023401013100200: [101230002122040,111124004101012,101210241204043,104102040011120,114103220220104,102120004001310,102430121110340,102020121102120,112141104020201,101200111020111], + 122041001000441: [111320012221132,102302144110440,102143202000400,111020002202333,101321311004010,102110241342210,100002320411400,100143034304100,114021002331014,100100104102112], + 1020020021012120: [102001404012100,102302200210010,102340120222440,114223204100010,111041202200140,111300400002313,100023014313010,114021040010311,100020004101012,102402000201011], + 100202040412040: [100043104240004,110002034200042,100001240100033,114100304002030,102100001340122,103414101212410,100424030024330,100123021223100,112302011102312,102400041110112], + 1003022434000120: [100200101000000,103110431441100,102101324130010,100011200121231,111201102224324,100102004100201,114040020021023,111230114102201,114201102342110,101400300300111], + 130220041030320: [102200001120020,100004400410040,100004210400203,100002431220022,110300102021320,102301221102000,101012004001204,111411000030222,100040011020200,101414411104011], + 103103120201012: [103000004012003,114000014014332,112303041103203,102101024022111,102020231440400,114030304122412,100023041030400,102014011102400,100020410124020,101013200321014], + 1004022310201032: [110004301222000,110221000111302,110022140120012,110024140142000,100321001001010,110321302022203,100002204310140,110110210011002,110221322123012,100020320002000], + 1120011002410001: [100034204311021,101121024024120,100102204231301,112201104011200,103020420121211,110341024422102,111031030040220,110024120430323,101403200302022,111400102104003], + 122013003210012: [103102011422101,102412201400413,102201102000000,110022000442031,112140202302210,110001042012030,100200104102011,110432132110010,101420304041030,110040222132423], + 111110310130240: [102231130213210,103214010102022,102000402041014,100043324210140,100023024211011,102404021403141,100003201021001,100122020011232,110002021121023,111102042213043], + 102331242012033: [100104341010424,103142210104020,114400240003003,112203001103411,101022001002030,100212024121000,101104040302120,100010001032200,100221110101420,102441030231300], + 1002301200031033: [102340221000300,101000130320340,112401314040311,100110020031042,102011004013000,110422102110221,100220124221000,100402002201002,111110004402021,101011014002032], + 1120212202013102: [101201000300102,100100034002202,103102111210103,103420240124040,100120110111021,112121011101002,103111010120121,111134204101221,110241211302001,110140300034040], + 1021003340101023: [110002302010012,114444044140220,101212001204031,112100232040011,100242011002002,112032410212442,110021233042220,102002200222041,102404414041110,102144044001000], + 110141003140201: [110124012142001,103110044002000,100000000413211,103024214000000,100403110022202,100021031020121,100001104100010,101013004000002,103131021420001,111200230002002], + 1024120002020144: [111104102242110,102210011101414,100002200410230,100044010200300,100003010413400,103334120114003,114032124013234,110112131124012,102143020230411,100440221001232], + 242303322114230: [111001440020003,102020204001132,110200020010003,100002214100100,102120104003011,102100144001112,120020201100121,102000041441002,102120402000014,102000200210032], + 1010342240120403: [102001404012100,1010400230221020,102302200210010,102340120222440,111041202200140,111300400002313,111101040014040,100023014313010,114021040010311,114140004123122], + 1144043310022002: [100042301001230,110002240134040,100040014310020,114000014100101,110031324200020,101110310331140,100300001003012,101430021010144,111210412213001,110000022201310], + 1120001001311304: [110100120400020,102113200210140,100031021033010,114030000030012,100000010202201,100012024210210,100120004300001,111140214103110,100010201030330,114022232303310], + 1403112003023002: [114400022321400,101302340312230,101000034000203,100200321200200,112044200243000,100002300421000,100202140430012,110200301210031,110000420020100,114304212302401], + 302212402010210: [103211200100400,102112231020231,100022004300020,102320000240102,100042144200000,114113104123200,102030304001101,100020420121003,102300040221403,100114021040000], + 312003244021002: [103301210142043,101110044200100,102411000200000,100400014321101,112012020230301,100010101020023,102000221442214,103142111441040,102140101343110,102242000200420], + 114400102222313: [111100114401014,110003112130100,110103011302220,102020440242023,101230000302304,100030021041110,103222010114132,102300121004102,100042024100140,100110004332200], + 132420000000431: [112020200242131,110240024241203,102020204010103,112432120204400,103130044003012,100022214101010,110001340112402,100142221013104,103040421244210,111111014402340], + 103200001210003: [100000241020300,111021030042411,110131011000142,100201134320102,110000302122001,103302031401001,110202012020000,110043414212400,111110004101041,100402000010424], + 220414040300300: [100202030140400,101024130300401,110010321011300,142011423130201,102000401130243,114031212300003,100442230030000,114002132240212,111001122224141,100000220000220], + 1044310320020000: [102144201343034,100430010431044,111020122230001,110111221000100,102100204000340,110330221300223,112020442310202,100023001030212,114344200014300,102240001302103], + 1420020302042323: [110141201302122,100000411231000,100023001222000,101002124002220,100101004230030,102103012004030,114034000012210,101044004000132,114114004140010,101010241113102], + 1012010000131300: [100122220023132,110204002043423,100032101220041,112003011121310,110110110133103,100130101220012,100400030022020,114302144020021,111012414402104,114122020031041], + 1000202200021220: [100000144201001,114202202322132,100000011032020,102022201320204,100002111020330,114432200001322,101040404000121,110300230102002,110103032012200,100010004340042], + 1040004023000010: [114200402332011,103240411403020,100020101031131,101010000323030,114200202330330,103101101440200,102142221401140,100000101031020,114000002302313,103012201401210], + 1010223022000012: [103110020210000,101420200304000,114024102212214,102102000212010,100233404320202,102210004110000,101142420012223,100000004204012,112214024003000,114001410022014], + 1120114042002241: [100020001044100,1340120100441224,1301223001003430,232020104433104,102330042000001], + 132302002220112: [114110200030200,101012130310043,114001310043110,114102344121242,110110104204000,102010021132200,102011001411100,100001410411142,111010020021202,114003300023020], + 100000120212142: [110021040020010,100001140020000,111011030004021,110013030020121,102001221100211,102100132000411,100121104300201,101220330300003,110132000024420,100011014130012], + 1042404102220010: [110034300021014,101042401000112,110230010000000,100112440013034,100011014101313,110104140001020,102011114000320,100041001211002,114200134110042,100204304122112], + 131110144032023: [111000024110140,102230100201001,110000401221440,102410104040240,112314301103022,100020004210021,102000222003200,100001040020122,110104101220110,110112211000311], + 1010220000431300: [100321004011041,110002342100014,111101042244210,110124002040002,110023410122402,111204200002001,111200020004203,100141101040300,103000104042400,110000011012202], + 1020310100100200: [111000022202402,100430211011410,110010340040012,110014032101430,104421312102244,114131014101010,102240214041033,114200322333401,103010021422042,100000001022401], + 130012120011424: [110010130000004,100000331040124,102122022000230,101011200324311,102301011004011,112030040242300,112400002021310,114030310030022,112224304041202,111103044400100], + 1024000412011400: [100031300002022,110210020002243,110210022120040,103002044002032,100101020402424,102201112000001,112211120202000,114211040011201,100020100423404,110001222202031], + 200000201004010: [114010200011100,100102110412002,100000204214001,102013024000211,102022000220004,100012001042030,102000404000400,102004004004200,101002134011001,103440411210000], + 124002021321013: [110412220102021,100300004310110,102002400430000,101200124200010,102143120210003,114310012300020,110003212104043,111011022203010,100001000100020,103211021423243], + 100230411103001: [104100202101022,101131141042121,100440000031023,110012012004102,101320244221142,103100401421202,100002211221402,100103301000402,114101022341020,110340122100210], + 1101210003102202: [100032041021210,110414300030001,111202012222402,102001301120112,102040041320010,103203401400132,103142111441040,114142044120310,110220410000040,100012000022003], + 100034000004222: [110001422030011,102144314002302,114200112340002,102343014022001,100211000430431,101213240301002,102240320200212,100140200410200,100020020120200,110210001214000], + 1101441010123430: [102021001132040,110201201211024,100032201024101,110221022101104,110023100402320,110123004401121,102032020214001,100040341020133,111101344104210,100410220030300], + 1024401021240112: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 1004230232322310: [103212014020132,100102101000203,114111200034310,102231301122300,103230040101112,102001004000100,111121104100004,100010041032043,102441311400421,112030004021010], + 1011344010300421: [101214200300004,114330120000222,110001440004103,110010022202202,100003030202011,1000301003020410,1014111023013000,110320044420300,1003300020121100,110201430400400], + 1122011114203300: [100000041040000,103004104003011,100101234301300,102331104110040,102300010242203,100020410410021,102144002000300,101233320302120,101421000304101,102011204023300], + 134041034223422: [102334004110232,103013000104404,112200102024122,103000034003300,112300032000100,101000100322140,114010010002314,114124002341030,110302322102041,111300202200414], + 1121000000204032: [102210011101414,102102011401410,114032124013234,102143020230411,100102014301210,100001000410200,101023134002011,101000131030300,114241402320044,102334040242404], + 1004201441103122: [114014112300100,114030034013101,100000044204004,101013004001421,103000014011004,101020224210014,114202244101041,100122310020400,112423102010012,102112022001414], + 1003040030421401: [103011424002021,111121204404010,114210000000224,111202112220003,102311110211420,122210101023210,101044111022300,110302241332230,110002004410314,101012000311412], + 1111110100002020: [110122120100022,111100424100021,110111121011004,103001020104102,100242444300104,110002202001202,110200422113400,110022300021012,112000000223310,100002214210110], + 1000000010122041: [102304340220231,102103440200402,101014424224002,100043000200103,100142401040042,114001032302222,101013404210010,110230000002324,101401304040214,112003011110221], + 1411020222201202: [112002110220340,114040210021100,102002220221002,114100234004010,100030410102000,112240334012440,102101010210022,100010031222001,110020200001031,100034021034000], + 1410002000001121: [114211010000210,110200020110120,100003040101420,101440004020212,102234400200230,100000004210012,110202102231202,102112000204313,100224120001302,101000330304200], + 1030012012011004: [100010400022200,102300001002144,102302444110110,103001000142003,110310004424232,100402012200112], + 1042202003423010: [110303120102044,100131031020002,102323304112342,114003222201103,110002022030224,100204011002001,102013301320044,100022204300000,112012211120102,112300000204010], + 1141404023020000: [100004001021111,101021004214202,103022021431010,100003000104203,102101220214011,102114320203000,114001112300001,101003104212220,102120231343021,102311110240101], + 1041400120014300: [110220202124002,102030024010020,104100212101210,111320000001004,101101021110401,101004204211203,110002012000001,110201002040204,110010402102122,100300024313211], + 122420402014110: [102000421131000,114404020003022,103100114000000,100421242201010,114410212320200,112020011110100,102030000221301,103300010110424,103020011430001,112000002000112], + 1023021104102301: [100001201220014,100210000032400,110200422121211,101213311020021,110040411222022,100041120200010,102303001003004,114010312213204,100400020022321,103211000211000], + 1100040012201200: [102020000204032,110000000003200,111401200000040,111202004100121,103230104003200,101041204222101,100024024211001,114031000012100,102110001342114,100222220001202], + 123003311204111: [101222321200012,103211144033404,103103240104001,102123040212103,100204104322122,102100011341012,114130000220023,102314224010213,100000120000202,111100230023321], + 1033101124442100: [100313324320240,100001310421201,110000110021420,110100410011143,112000221133021,100130000010204,102443324020000,101134004004013,110401020100113,101214311020403], + 1024102010130120: [102020000204032,110000000003200,111202004100121,114031000012100,102110001342114,100222220001202,110200000004322,114342044032200,111110020000001,100200024323300], + 214432414421000: [102100321320100,102102011414242,100041004100221,100000000412112,110000010033022,102330040242220,102140121410131,102310400240000,101201340300430,111320312222220], + 223412000312023: [102100004130301,102113020210120,102201101122100,100102114100420,101012310342300,102321320224101,100002404310212,114012212302132,100430324300003,114230222331120], + 211012410102104: [114404220000142,101100214003002,100021231022220,102410420230111,102301220210011,102120004001102,102323210221002,103211001400330,102410220200400,103020210143120], + 1002023202310442: [400004112102010,1200020030443142], + 100100002221212: [110231434430114,102340144111123,100140010100100,130011204200020,140243003020120,100120014301440,112020240233004,102144311342041,120422012013021,101040400300024], + 1044010413203120: [103130021444021,100022001040322,101400004022210,110020030024004,102112204131410,102312301104422,100000411002023,102303200241200,100022021041122,114120140000100], + 1400100210120201: [104100012102004,110000010120043,102102011413000,102403404004110,102031024013013,110044020020202,102122410220401,110301311303102,110021232000021,100001140000010], + 1040312010102100: [100004211221210,110201001212001,110200134240420,110403221000002,101201304200320,114022042302201,112002320212232,103310101401010,103140021401211,102404042001400], + 1000300001000101: [100003011041040,103200141404212,114001112300222,100203141001002,114122440000024,103000020103121,101200024010043,101044211032201,100011111032203,103021440122032], + 201034002100400: [110003004410041,100000444104204,100014420000000,102012004013201,100104004230031,100021000021202,101400000302113,112211030201201,110432304221110,110410212110111], + 101101331204020: [110112012140003,112110220202020,112002012030102,111003410011000,100400100022002,110300200044430,110401422114111,112020021110112,112120020220421,110220244403201], + 1122221100001000: [112023022001022,103122221240032,110310022220010,102001000202131,101020401034111,111012400040302,110140021322121,110120202212130,110013140003302,110220002040001], + 1020000002421121: [100200011001220,111202014132111,100003141022321,110201434240143,111030044110010,110041304201404,100040211022000,114000134102201,100420104301012,102110001401111], + 201022410220300: [102020410220200,100013014101040,400204300024034,100402010420301,102022110202024,102010140220011,1002102003210222,1130420100342202,102120000210110,140020100011012], + 1001100100001221: [114203000004300,103140044032100,110322100104010,100032021041010,114100004121121,100040214102023,103033044023040,102403101400210,101000001001104,102100330231011], + 1424104010001321: [114213002340022,120402022102021,102120140212001,114400210002021,103103221421013,102010002000402,100240011000013,114233112330324,100000021022400,144200203310100], + 1403010413000123: [103142100103020,100100014033224,101002204213002,112001002300102,110002402130200,103144111211103,112202002030000,110100001014012,112243034012420,110010344204120], + 1022030220022102: [114022300022421,111210044410020,111420230003130,111310004122000,101221000312044,100400240013333,111001314111000,103100040210040,100210001002200,100001210100102], + 1104301030300303: [111220002220100,100000241020022,101133410300302,132200010004401,100030044202001,110114410003233,140200430112430,110012030002010,110000040024442,101410044021332], + 131420104131100: [110230000000002,110220301202400,101003140322000,110401001002400,103012000100400,110210024220020,114201142324042,100401424300314,102213401111223,100040120000031], + 202204411100110: [114231202331202,100003021234044,111102032220111,110200204224211,111300042200340,101010041032322,114020042300022,100021421020002,102400004040100,111120204100203], + 1111100011232413: [104120011242011,114300000000002,110020002104100,102111400202120,102000301101102,114100124002210,111122200021102,112400034040002,101041100300001,100000020201032], + 1002000201011131: [114200302320443,103100420210210,102132004132023,102040240242204,103224020100300,110030012000101,100403220022142,101001240310031,100000101022200,114030000024010], + 1004104010000220: [102231130213210,114113104123200,101210210300031,110002021121023,102300040221403,102201100200430,100114021040000,114121300224141,102301100241002,100021020412110], + 1421021020110001: [103132204001001,110003404411303,114410010001200,111211232220002,100112301000311,114000142301404,111301032200412,100210011201011,113030011000324,110100120120001], + 200021104204110: [111120230020122,114301000000002,112124310203104,100113324103000,102001000221124,102023021321020,102114020210202,114040204014042,114001010044120,101010111033143], + 1120310000031004: [110411324240311,101011034000230], + 1112021100202003: [114031004020241,102430321112030,112101432300231,110213042222211,100320224314301,114202032320004,100040014101440,110321100100401,112200102033440,110100000101440], + 1102000220103034: [110011414240022,112004202302034,100042001020203,100010044300003,114130210231020,112120224040040,103301410110110,102124031023100,100204104320231,114002104020100], + 1440232013001100: [103012024004312,101040040300223,114234004000210,100100001040410], + 1110140020111223: [100321004011041,110002342100014,110021312002040,111101042244210,110124002040002,103110314000100,110023410122402,114302200014241,111204200002001,100002300411002], + 1222102001102032: [110200321303322,100010030100011,103002041402004,102022024000100,102103030210003,114120034123300,100040001230110,103010011401200,100020014210002,114010112332112], + 102121400201014: [111124004101012,104102040011120,114103220220104,102120004001310,102430121110340,101021204000200,102020121102120,112141104020201,101200111020111,110001200422320], + 102010300001011: [102404004041224,102200041120220,103220010101140,101140014001001,114101002200223,1034110304101100,110021041330000,114321140000202,121102001120113,103322000111220], + 110101402310010: [114011302301400,102304034110400,102100220210000,112000022000300,100003214102204,102430300201034,112030122000001,101102104020404,111222024104240,112000102000001], + 1013400111031002: [110300222104222,100002040410130,100440001000012,100403011002204,110202414214022,111002420031340,112432142020024,101103012130233,102320304030000,101112241010002], + 102003130120100: [100001230201101,101101131132022,100010100000042,104120211242040,112220104002000,102223004042102,110410312121010,110330130010041,100030034303012,102422200201100], + 122040420010323: [114203042330220,102102231400111,100032421040120,101004201001232,100000400412200,100002020101023,111100232241200,100011234202334,102111024004010,103343010113030], + 1031013022303011: [110000322130121,100200001210021,103204230111030,100422211004214,102100000210002,102121010210004,114013214010111,100010004210020,112002100240200,100001404100110], + 221002402022003: [102021401410001,114210410000401,102002410222340,103210214003143,100110000020111,114401000004202,100024104100032,103303000112122,102100014132110,100021304103002], + 1001100210002400: [110322104424202,102112201020000,102102220312102,103004204021310,112220102043102,110012310020200,103030120100220,100232224340041,112400002011010,112011001113222], + 212002400114144: [100032041021210,102040011121100,114310000001232,111322234130000,110104002010100,100030024303023,102042204000300,100001134100120,110303401230040,110024140142000], + 1120324010000221: [114040300043111,110203111111000,114010030024204,102010201012014,102041204000002,102323204112320,100402201004014,100420404320101,102123414032304,112401014040034], + 101031020122412: [100000210100030,110001440041003,100000220111021,101000430320220,100401022201110,101100001110030,102210011101110,112100302012023,100102410403204,110042021100041], + 200422320010040: [100000210410212,100202021212012,102000032003002,104003410010031,103020201401104,110020030011011,100100000012334], + 213123000110000: [103010010104000,102330030243120,102100100210033,100002200014412,102140142001210,100141004030100,104130442103041,110000012124020,100022201040213,110221320111003], + 1002203431222130: [103241000112010,100034114100102,110330002104200,114000000030300,114101012201420,101114420310142,102112100210100,110011111104432,101300000340401,100011301210241], + 140000130120401: [101000211032200,104100001242022,101210000300320,102120022000224,100204000410301,111213130001022,101030120340201,102121444003011,102240121302011,100401400022202], + 1020020030010202: [102202204040010,103333040110114,101022200343023,102000000221222,102011014001111,102331201001140,102101001342004,102103001414002,102022011101012,103222024031400], + 1000120402321010: [101010400300001,110002211302010,100040004310211,111101144403004], + 1111020032213240: [100404210032112,100121010022020,112100322040040,100112134030041,102000000224001,102013314023030,102103111403000,102004044000100,110030121201003,102110030210103], + 204240141002041: [101022000322012,110123000122000,110212010000000,100200020144110,100230421212431,100101201021044,112400000200011,102112400224210,100400230020212,110440401003310], + 111403302134022: [102001144013040,100012111020031,112203400410130,100302320420012,102000404001103,100022211040222,112012220214324,110030400140000,102242022004100,103043001412001], + 1004010321040430: [100104100022200,101010020320410,101120201100110,102304021004012,110120001121422,120000042021310,100100030402102,100300414022102,102100234022140,101024124000000], + 140113212104010: [110211002121001,101442031012013,103202000101303,110020232002103,114101004000301,110012311001312,100241100430000,102102400314222,111022022233042,100120020401013], + 1103120200120021: [110134044242442,100002302213022,101030020022301,110120400022300,100041044101100,104032420010121,100121104031022,103004030121000,103212210100022,110144200000122], + 120101001020342: [110210400114203,100001100104021,101101300010301,101122200300011,112210201100012,102120200221403,112001122302311,101001211004233,102303011002000,102314100240010], + 1002132023000020: [114001204020002,114230000001013,100022211001110,112000002310000,100010201030300,112420104040020,100403430013124,101002100322211,112004000230002,110220111110412], + 100000200014040: [101242011000124,100202340430142,114420242311240,110141001301302,101200200300310,114011402303024,112124000203110,101011000320010,102020004000040,102110201342301], + 1004311210021102: [100114004100001,102012030213014,102003320200411,112440114040203,100401001011010,103001204002010,100340114211043,100033001220020,101100120334014,114233002340141], + 1240000303230010: [103204424022010,110304304420001,102110402001413,102131334020220,114210024001201,1031024222000122,200003020011141,100020111230000,114102010224000,114301012300202], + 1001310301020000: [111201000013222,114004104012300,114211202324143,101203211010000,101200314040213,103302140112020,114003200023323,100012014300020,114110024000020,102213214110012], + 202000424030110: [101020000300112,100002020410020,101000001111200,102012220241003,111120214102000,102113200210140,103130020213032,101430211012120,102323204113210,102403031110014], + 120121341000001: [102041100200402,112100404000230,110400112021140,110112121002403,110122221240302,102401200230234,102241230200120,110201111200204,110400104222012,103302024010240], + 1400200011214220: [100002101021120,102102012003220,102313114114000,103030304021102,100000101001431,100104100422041,100001044241012,102030420223110,102120200201042,100200011000020], + 101332113114042: [110144240011020,110011011212100,101134030011000,112000244001222,114441114123013,103220211421421,110123230124040,114000012334102,101000014012442,131000001020102], + 1000030222202004: [110221204243141,100400220010240,102300221002020,111010204401023,100000010004124,110312300040010,103120000104021,101220200040320,102102001402012,100124221021011], + 1144441010000220: [112002204004403,103013001430040,100402021000101,101104121111112,102141032001100,100100220024041,114000000023404,103030200142241,103010040123432,102112322004011], + 240201020200121: [111133110023322,100400024103122,102000021101201,112024200220201,101001440303020,102000124010400,103002224002043,110140141201202,112012030233024,114201004001120], + 121221411100014: [100012320001320,102000331120104,100232214222204,110203111111000,112104212010101,100001104201201,102300221002020,100002101020010,112010202000202,102033024010010], + 1010044020430310: [104120011242011,114300000000002,110020002104100,102111400202120,102000301101102,111400214442024,114100124002210,111122200021102,114032234033303,112400034040002], + 1020000200222300: [110402402020010,112421302011301,101023431001040,110001210120320,110300404422030,111024100022301,110200310012010,110102110124010,100000404341421,110000022100112], + 110302143030000: [101201004044021,102422122000001,100040204202102,100200124341000,110021212130000,103230324024140,112120022010120,102113111410044,101042130310010,111202014413200], + 1031222012302021: [111304340002030,110102000401214,100100111044040,103140014002031,102024102020000,102224241110003,102001014013004,114113014000010,114022100010000,114321004030021], + 124203022000303: [103100221440010,114003344011001,100021101000000,101014201030204,101203001010111,100031201030102,114201104114111,101041001003300,100001100411302,114012444020220], + 220102220004103: [102342110212020,100024024200032,221123404200214,100021024100301,1101210010010223,102042000211301,1300004102024404,100421001000020,1300102043130042,1333020210312100], + 1113300400421010: [110021000410432,100042304102210,103202000110102,102020440220202,101010010320112,100042000000000,112000021122010,100021111043012,102122101023020,110124041140000], + 1130010120120310: [104130242103012,100002131024210,102410001402210,102000101132400,110000102100012,112023140212112,114000312301300,102120214001422,102400231404200,114200422324023], + 1000412130010144: [114042102330002,100014001041000,204020131034103,114113404003030,102310030240210,102100204001030,102200400234000,103001324012043,102110222004041,100102240020100], + 1400220101000132: [102023000220003,101004204212040,112130030422202,102202014030001,100444021001102,100020404302120,112013400220104,101022424011430,112112002014120,112321041130330], + 1000141214101410: [102101320220430,110100010000102,114020444100202,114020232302203,100111120012323,100014044200222,101001000321032,101124021110021,100023100104410,110100112141141], + 200000101104221: [104132340011314,102203304123030,114012040020310,110000212104130,110200200004002,101000040320021,114131040224332,114002210021300,103230114000201,100123020032031], + 204143214033312: [110000212101040,100014401210011,110021410020203,110411044221200,112024232302040,102423031402210,114013022304040,102021311100042,100201020140421,100004001002300], + 1440020223001243: [110241142024233,110023342101220,101001421031220,112300421134001,112220322030220,111000034110311,103021004014220,102200001002100,100014100124121,114443304123123], + 112003102431000: [114142204123102,110200002111002,100012000002410,100201131000322,102000024010442,110141400010211,101032001140100,101401400300110,100240414222323,112002040210000], + 110000140021401: [100002200103104,102040300241403,100431000032001,100202031002101,102103331400000,103013004020003,102222310200400,100204101210044,102021024004322,100001000013302], + 1110223000120201: [100010441032031,114402414111240,102040444014121,102012110232021,100024100201424,102002230200001,101012011001200,101222000300004,100003014211000,102400204024124], + 1030312044024302: [102400111402142,100010000002400,141030301403400,100000024100211,103224200113121,110140101300004,120020211120020,110230010010142,112003000230111,102031111324402], + 103411200010022: [100020300200110,102342110212020,100042000200211,100024024200032,221123404200214,100021024100301,1101210010010223,1300004102024404,100000134100120,100421001000020], + 1000201421400142: [110101210013000,100404121014002,101240220300022,103011431401300,110120020002304,100011000202214,110012101102100,102102304001200,102002020220000,100102120422002], + 324204022022230: [110013202003320,101031241000010,102120231343224,110030332100203,100314114322101,114404232310120,103100034001310,114002202210331,100031301020100,110111032140220], + 101000431101102: [100122420031012,102202401114113,101021001031113,100010114310001,100320140043202,112030312300010,100123341012403,112413022010001,100403410013000,100000021034001], + 313040033004011: [101004400340300,100130410400000,101020404004141,100100314003011,110430201313300,110000224410102,102010104040420,100200201200001,110014002130210,110300200400111], + 1020141230100100: [111102004100101,100122004300410,102202414041044,102140014001101,102000104012232,102021100220101,100230120001003,112042110220004,112203221102231,112400202020003], + 1004102100041041: [110443010102111,102020101324002,102401030202031,100210031004220,111321012222400,114203204004133,102401004020304,100402200013400,112300021131001,110100040033204], + 120420321011020: [114040210021100,101001440344222,100020124303001,112414130200030,110000010003422,114010002242000,101120201104300,100300030420140,102340021100202,111031004110200], + 122020021031230: [100030220100110,220321332020001,114012002212100,100002114314022,114203110001031,112030122000211,102000100200100,102020400244030,111004012200210,103112100101020], + 100210000030120: [114041300010302,102011000233013,100030014212420,110000000021142,102114002001012,100014200200204,114120312310022,122213202201022,102212140200424,114203024110400], + 102221004014241: [100301301000024,101000321002030,101044400300030,100100310024040,101024024002120,103212010100200,132224022200202,100231004331011,100200010434042,123102041021330], + 1031001011004000: [102001404012100,102340120222440,114223204100010,111041202200140,111300400002313,111101040014040,100023014313010,114021040010311,100020004101012,102402000201011], + 231020004100430: [110023342101220,100021004310222,100001000100000,112220322030220,110202222043022,110313312021120,100220214333200,110330234422000,111000034110311,110243000001123], + 122231001303344: [110103002040200,100004024202000,102303311004021,102000101410104,102112430210103,100010004102244,103000114012224,102321401000212,110101020124104,102042444010014], + 1023012341411200: [100030324200410,102110202001010,100040041020102,114200020003431,114041002212302,101002200343110,103332044032320,100212024322044,100140004102001,114101024122320], + 124240201203112: [114000040010421,100433201004014,112002010220004,103001131403322,102002304013011,102320001000040,102000034013222,102120004134001,100120140421132,112010002001040], + 1111113231201402: [112324002020202,100120221021011,111242212222022,101401140300101,100030124210101,103220200100320,100011224100020,101030004004303,114203224111020,100140304103400], + 1000241010023032: [102112201020000,112220102043102,101102320320033,103042000110130,100002110202020,112121202014100,103030120100220,103101101210002,100231200100003,103224224022200], + 121021000001400: [102340221000300,100402002201002,101011014002032,102104101122100,112002010221020,101131201110300,111012030020003,114200404001002,112000011111003,103210230131414], + 101011222214113: [110130014400011,110232002101410,110331400400440,114021140030020,100424331001120,111040300024044,102120204000310,114021112203114,114000004110202,110111302000104], + 1000030000002442: [100032041021210,102040011121100,114310000001232,111322234130000,110104002010100,100030024303023,102042204000300,100001134100120,110303401230040,110024140142000], + 100140304030003: [101210320301302,100440024301100,100114104101001,101023221000031,101400014040400,102012034000402,102100122002001,101000011021414,114101000221221,114010214101003], + 212102012212400: [100130320031042,103110021442200,100042001020203,112221200410000,112023032000020,114100110220013,100010330101003,101431304024200,100002241200002,100013014202033], + 131021001033104: [110021310040113,110301331234001,114403020002032,100400110020001,102120104000032,112402234044121,101020121032021,112202240410200,103110201240222,112112220204023], + 200004200100022: [100021000104004,100002200022012,111140204103210,140004010302423,114200320003120,100200113201000,141220400002200,100044231103400,100411033204412,110000001210210], + 100312211012002: [110002212130403,114112014140000,100133004000124,112440104042121,114200124000134,100120204234213,100003011231420,103230231200010,100222200002003,100431031014023], + 212000130000300: [100000044301222,111012034402110,114221004034110,111100104104202,101223041020020,102002204000124,100011230120014,101104024002242,110133120011001,100400010013033], + 200441004232120: [101021120323020,102001111412134,102110010202100,102110234020204,100004131024040,102441311400421,114020214033220,100010040101024,102001224003302,102111221401002], + 1400032011030221: [101003201032030,100103214302031,114233044002100,112310000201020,114404210030110,113400201011402,103202114021110,101101334200302], + 1000200101002322: [102023104002000,110304044431200,100310111001140,112122104040040,102103131122203,102100101140030,112120012011020,114002104011010,102400014020400,112412034040100], + 1100104020042012: [114011302301400,102100220210000,101203004042010,100003214102204,114221000210214,101410044041001,102422214021111,112030122000001,101102104020404,103400004000422], + 100311004230102: [111010124402202,110211020121140,100020244310231,101000030321102,102110320210011,114221234002100,102420001110301,111231000010032,111110004100240,111040102144100], + 120102102023401: [112000431120410,100031034311401,102304104110001,102000200200301,100104211044110,110200101200402,114241222321321,114013124030022,114104200220022,100021221021201], + 1021100110422300: [111114010020011,110304044431200,100310111001140,104104112101440,112122104040040,102103131122203,102100101140030,112120012011020,114002104011010,102000031442000], + 102001212320334: [100002100100210,102420424042020,102000430221040,100100000422320,100102020411200,102100012002000,114221030000011,103002110100200,101320224220103,101302131002410], + 211101130124014: [103111001422000,111244302220204,100042100102211,100300041001121,102110030200120,101114000332010,112112211102024,114001032300011,100142044103021,101100010012423], + 110301010212010: [110112320021204,100034114100102,110330002104200,114000000030300,102112100210100,110011111104432,102000221034000,102300044020403,101113231111221,110020131231003], + 112004100001031: [103102300102243,102113020210120,102020000204032,101012310342300,111202004100121,102012014000404,103230104003200,114020404101101,102321320224101,114031000012100], + 1001033204013302: [100301300121100,110042400130000,103020124010320,100021300101201,104101201240100,110000011012202,101244324043222,112102232300222,102000020241101,112311000204002], + 132014411000000: [100100020410000,100030411042022,110401212110230,100031420002140,112022400231120,112203321101101,110002421122102,102124320203002,111024204402000,111014022142334], + 1100300303302222: [110000322130121,101023001002020,111300222202234,100200001210021,103204230111030,100422211004214,102100000210002,104130020011020,101114422122000,102001314013400], + 1000213012200131: [110214024430312,100011014100041,100212341003212,112013212032000,112010220224003,112001040231401,100200001001300,100012104313201,110212310000041,100040424310110], + 1240010040112110: [101010000322013,101123211100242,111400130001014,100001420000003,110003142001043,100034031042100,101121024000024,101020301000022,111130100032240,101113311103230], + 110000303120120: [100012230204000,101101200311102,112401402023020,103142104001331,100200204123011,103031120143010,110020211221100,100101130101111,112000210230234,112003104002414], + 1041004402334112: [102021100220120,121000033324102,112024201004140,104400020040320,111022320201411,121410000420112,100004140041201,130432000202002,100444004201203,122100042012100], + 1402311031204100: [110104112010103,111102004100101,102202414041044,102140014001101,102000104012232,102021100220101,100230120001003,114000040010421,112042110220004,112203221102231], + 1033444000022010: [100011004343022,110401140004202,110040002034100,102402330230011,110203210002230,110432242020141,103202104032224,102013011320122,102110334020204,110001031212302], + 1113001000402001: [100441224303402,102401030202031,102401004020304,110112214200023,110100040033204,103104404000040,111201024102030,110100102010003,100122110401300,102010024001100], + 1011000000302241: [111304340002030,100100111044040,103140014002031,102024102020000,102224241110003,112003020220120,114113014000010,100043024210301,102014001130100,114022100010000], + 1040204043040400: [103300040140032,102104211001200,103300001404011,114211002340000,100002101231220,102040424014311,102210044011101,102000034002011,114240044002001,114302002322001], + 121022040003003: [100140024100204,114001014102403,103210000103000,102120101343104,111122022240223,144410130020302,114302000000201,110420412024420,110404044220000,102121301022010], + 301010203021201: [102040431121110,101221020040220,114111100021420,112024212301420,102212000200124,100300310140241,100240134323001,102141212000200,102042000222002,114402104142102], + 110013000400024: [100011000202214,103040020122332,100000024100000,100010040001210,102002020220000,114302404002020,102001121132032,100001300012442,101012304001200,100011114300032], + 1030201242040022: [111034014401112,111302202200213,100030241043214,101421001021031,101300400313000,101220040310221,102320030240003,202030010203100,114431310000020,100000004300240], + 1010110212000220: [100100000100111,101300340341000,100111341011011,114421030000000,1020210020000020,102102211122031,102300021100000,1102400141403322,102223314042002,101200040300300], + 101422210020110: [101000141031222,102000421131000,102020111324004,100421242201010,100012424200031,102043120222040,110200200001000,114023024101231,101410114043204,102101041341001], + 120220041041330: [100021204100204,110211020000002,103002034034022,111230214102412,111433044442220,100113410410320,101000004013020,111201442222420,114012000022010,114222440003300], + 100031300013400: [101222101202341,100020220410142,110000412003001,120202201010210,112042024000020,110022100044100,114400200004310,110003000024101,100010024302100,100000011020412], + 200110001013001: [114000200020423,114002100033010,112111102310000,101241000301002,110040041310130,100004301000000,103302240110002,114011134010000,112002020243001,100003014301220], + 1042214111030100: [100113220020101,114031000022030,103103241421322,100300211000020,102104304023201,100002224244002,114310200002400,103211220100010,101202201021310,100021404301132], + 1040330100310012: [100111011011011,100030040101021,114310102300021,102400124020001,100102224234101,102010321411140,102111131410342,100031120413224,101304004220404,114104214003030], + 241314003100002: [100024000110221,114130014001202,110010220103020,111004100022110,111001344400222,101021204010011,100404410022320,103012101410102,111000000000411,102131304003000], + 1100211001101030: [114201104111034,111130210020000,102114022004023,101022121001000,102300104110002,100104201020032,100024000101404,103000014004300,110440302011221,100101004301102], + 101014240242201: [100024210002210,100000020121140,103000200111020,103022204000200,110241020002103,102023021100010,100221020410103,101120241102203,100010304340120,110020010120340], + 1004002010012002: [110320202023400,110441234224400,103100014031411,110000300424304,100011004343022,110104422010121,110013122130200,114020204102020,102402330230011,103121221400012], + 1101301421304402: [110020020001220,104120000021110,110102030403010,101040010314220,111211114421220,110000000011102,110400000004402,104101420012000,110132241240004,102010411120012], + 141210342201230: [102200020211042,100000034312214,102103001340022,134402411001001,100002110000131,112021020220112,114201414110004,110214012030140,100000144311102,100000104100100], + 120013202112200: [114402404141241,101100000330120,100000400000241,110212022133311,101412001100222,101041210311410,110022004211030,101210021021243,100140024230240,112230240412241], + 1121212241202220: [102222111120010,103200224033413,102300440221022,104120201242031,102320110240231,100100101011200,100133001220421,100122204301312,101022220322100,100114113200203], + 200321214231321: [101011004212201,101010304000003,110032022002020,100214230430124,103031234000122,102044021101411,101042001021012,101100104002023,103230011412301,100400000010020], + 100400142000010: [100032041021210,102300324010203,102040011121100,114310000001232,111322234130000,110104002010100,100030024303023,102042204000300,100001134100120,114023214101310], + 1000010110003420: [111122100010330,102302231004020,103001000141212,101202104010412,114234414102011,132012000000230,100014001040120,110002400011111,102220000201200,103101011421200], + 1000002414112210: [100111004103123,100003021034002], + 222241000310020: [102203304123030,101000040320021,114002210021300,103230114000201,101401300300011,114121002310010,102042210202230,100141120014242,103141131420000,114014002300100], + 102020320003430: [110201001212001,110323344422123,110200134240420,110112001343021,112002320212232,100002210413202,100002101020204,103140021401211,114002212210110,114212000211041], + 132210004410012: [100032041021210,110004301222000,102300324010203,102040011121100,114310000001232,111202012222402,111322234130000,102040041320010,110104002010100,100030024303023], + 221320013320110: [103301201402204,102401121113302,100021020124002,111201210000103,102104131412412,114020312300021,101320040302031,114010102300010,114042014014024,100000000200102], + 1122010000001340: [103030114020032,110001131312220,103000001400001,100004020001220,110202042021023,112010334002223,100011000002042,112234000202010,102000124010244,112400114041042], + 313020103000100: [103212134020020,110111412010000,110023210130031,103203121201001,100000331231114,111310122200002,102001311100000,101410101013004,102400201112240,101120040330204], + 100100010214202: [112000042030034,111200002221022,120201012121032,101002100301011,110101211000302,112204010413200,112000020224300,102020011130021,102013341121201,100222000410322], + 300001100022010: [102040431121110,114111100021420,112024212301420,102212000200124,100300310140241,100240134323001,102042000222002,102001011100100,114402104142102,100030010102102], + 1000102011020210: [102201444044432,114111140220220,100000304102031,114302010000013,100311010140302,100100124003241,100002310120001,100111014231402,100404300013220,110220022111241], + 1142220400000210: [101004201002001,103112010213010,102121001410120,112200410200142,111400002102112,100034100124302,111112214101000,1320102201231021,100000040413022,100011221224211], + 112000122210000: [110102042010220,101020124000413,111210000001101,114013400011030,101201104040034,101020111030400,103004104010210,101220024041000,102010300201414,100202200003011], + 1114114400220103: [103102300102243,102113020210120,102020000204032,110000000003200,111202004100121,114020404101101,114031000012100,102110001342114,100222220001202,111114004101202], + 1224100000124204: [102033124002102,112410202021300,110000201301004,110002040021102,100000001032140,100110221000310,100030401031400,110031001010032,112220100201030,110002212132131], + 1430010401402203: [104100421240110,100042010103431,110041221200014,110301122022204,101400004022212,110233020402400,114020040031020,110010000431131,112420200200110,110432134242300], + 243400040003010: [103042110104101,100210104330243,112001000233022,111003044110202,114330124002101,102230231120222,104102122101021,102330021103040,114020040014403,114002024100000], + 201101204001013: [100004221034100,102232024002401,101102120301114,103400014000012,101000004001310,110120224221100,110000041322002,103412020132101,110041021300130,100001200120142], + 1021030030402120: [100101201011100,110400340004400,103440000124310], + 100302330021101: [103132220100130,114100204121401,102120214131012,102200324111003,102004134004013,110220034212001,101032004214120,101204011020202,101002004014003,100221114242000], + 1404102311222402: [114233024103200,102120304032340,111211414134201,112200001100121,100140101203122,110202200000012,103200414020231,100103040402230,100304004210210,101000021030212], + 1000000004020102: [101023001024400,112020002311112,112000030210340,102201000203202,111200300010114,102010002000404,100024220122100,100004304100003,102040004002144,100011140001404], + 1423214230403402: [100200104321000,103220030101023,401300041114001,112032302000220,112003000230001,102004301444000,111133030010200,114000044101422,102020204002424,100003014101004], + 1102111400312102: [110401100400430,103143111443210,102112212004043,100144040410322,110103221143200,102320001001023,111033434402423,100400402200402,110020100110002,112231010412402], + 1110100401222300: [112004202302034,102122214131011,100023031000024,100010044300003,112120224040040,111321314133000,103301410110110,102021021101204,100231020102202,103014004012401], + 320102010042223: [111010224110043,114200334112132,102140201342144,100100121021000,101000011141243,110122121014321,100400202201130,101330004220011,103122034000212,103120121214001], + 1011200220321320: [100034304101213,114002014100310,102101031412121,100020020121132,103311100112220,102102010220401,114402044140023,100021120201020,111000024404021,101202014010400], + 1102100102100020: [102001301130211,103202102201112,103042224042412,100201202200003,100000420100214,112000100210200,110204140013401,112440102010141,112443012010041,111304402204411], + 1042030133022202: [102104210211102,102214040203031,112220010202202,101104224022322,100000030002013,100030244100404,100120101022100,101023204012124,100400212201003,102100010200141], + 1104322000300041: [100024000110221,100110020031042,101301014221122,110422102110221,102102204022310,114130014001202,110010220103020,111004100022110,101002201140040,114040210022000], + 1002212230034111: [112211122030420,100010021034321,100031004101422,112013012301132,102001104001214,112100140200020,114214220001140,103144001420031,114024104100321,130040244231421], + 120033201000210: [100020201020032,103000011400001,103001010101001,111030014120004,101000211031021,102020001021010,111300022201241,110402410002000,110020001210102,110000020043321], + 1441220011132444: [102002301120010,111002100000102,110001000020034,102004014000430,114222302321101,102101024002121,110014024202014,110220130100010,100020011030330,102404221402210], + 1001220202022300: [101220014012231,102010130231400,101010311003410,100020424214024,103422430124013,103214400131240], + 1020121100031001: [102104410220023,1024002314000141,1101200200223021,100430200104001,1341420023200031,103220020131102], + 1030201204043041: [102021401410001,114210410000401,102002410222340,103210214003143,100110000020111,114401000004202,100024104100032,102100014132110,100021304103002,101120024021024], + 130112000110201: [110000002100440,102330031000000,102221410200012,110422010000200,103112021442033,100000204312321,110213401202110,102300104113403,110300121220201,100400440012042], + 301240023002230: [102000214001143,114000122300001,112133002010330,102110001342041,102000344000000,112201031104011,100001004200110,102001101132013,111320000010132,101200420011300], + 232201201211042: [102140024002342,111114212112100,102312120222342,110002004200112,102020010221120,112012000232203,102143121343400,100220001000401,102101004002030,102303130242002], + 200400000400202: [110000002100440,111214100000104,100430221011100,102221410200012,110422010000200,103112021442033,110213401202110,100400440012042,110044014410012,110030231214100], + 101004200000022: [114212012310002,102004004002321,110001420000233,110000230010221,110202110113000,102200301110320,110001040000000,100324114310222,110002242100100,101220100303222], + 131401202213441: [100212201000030,110020122101104,104130030010110,100000010411400,114042004020130,111120112103420,101002304210122,100100014000020,112402144042221,102100340232410], + 1102320110211010: [102040431121110,100400002201113,114111100021420,112024212301420,102212000200124,100300310140241,100240134323001,102111024000402,102042000222002,102001011100100], + 1211021010301410: [111002100041311,114011102301222,102401410230032,111212420010002,102402200203034,100001230102304,102102001320001,102332104112211,101020101002120,103002204003100], + 120000101024021: [100420244300112,101012001030010,102230121123103,110202010012201,100221440000230], + 112211003202310: [110330400010040,100101231004020,111000100012002,110013112004021,100143040411011,102404404004104,114002202302000,100034000000002,100400100031022,110020130044232], + 1022200220002201: [103041220111410,101100202130022,103400104001342,111001212200200,100000331201012,111210214440200], + 200200024404400: [103124001420200,100220210034042,114434330000120,103224034003141,114202022320120,100204011000221,114412402323000,100000201032240,100204401004031,101240204232402], + 1010010000020000: [100002021042230,114011244103110,110022224202024,114043402214302,100104210400100,110213042222211,110002100132300,102002200200004,103100001420200,112021104023402], + 1432102131420423: [101001111020310,114002102301424,103141324004100,110011234213300,100010030104002,103120100104000,100011004201102,100024211212040,114121012340403,102001004011002], + 111003010102320: [100020121020300,103432001210300,112440134041000,100210240013000,110401214242400,101044214042221,100033201031241,110010114210202,102141000313022,110110114221031], + 1032002034000000: [112001001112001,100310444310004,112332000411020,102431200203321,100211001204102,110002400042003,100000004244400,102032010241003,110024001211221,102403204000000], + 100022130000100: [100000211041234,101130000023030,110013322004400,101221200010202,102100014031110,101010101034002,110004342121110,101011014001201,103210244041141,103021401412434], + 1431022230401243: [103310020140014,112000204002100,114401400003130,100000000411240,102030021443010,112300220202122,114010000024012,103100421422110,100102300401031,112120002302004], + 200300022222204: [110402424222014,102030024010020,101001011114020,100030044100103,110001141011223,102012040223003,114402240003200,100300024313211,114022012202024,112023212001400], + 130200034014232: [110032022002020,100400110020244,114011120010030,100411201002420,114120040222120,114304234022130,101030404003400,110002004413040,112102322011013,102201100230002], + 1000023212220222: [100002221021122,110001041100000,110311404430222,110342230013000,110000000040230,110004031201142,111200104440321,110032230410440,111300222200201,110322014420041], + 101034041310004: [102442024024214,100443211002141,101012400320022,102100330211131,100011014103012,100030220101040,101130031041024,101240021020011,103140100210304,100400020033003], + 1044013000043020: [114113014000010,101200210302201,114202400003330,111201222220201,114330004003002,100102001040033,114404022311000,100002324211100,111231042242020,112100204041010], + 1022140303310000: [100310304310342,110140044401202,101300124221002,101120101100112,102000300200231,100002030410210,102231031123103,101043314210310,100314420140013,101401204040200], + 210103424043221: [100004011220200,114013002301104,100044101022021,100030021041110,102101320234011,102002400210101,102400204022024,111102142213410,101000021004021,100011100412123], + 112410130013220: [110320202023400,111431110000042,100302141003012,102004441124110,103303201400021,100000301221024,101224322120022,110104422010121,114100200002120,110310020040401], + 100202003303000: [101100000330120,101214440300301,100000400000241,111102214104403,100132004231230,100033230420102,100000030000001,100222024100230,101412001100222,112000042000001], + 1002001241003040: [102414440232000,104130210010324,102201204040211,110001004202040,100314041003230,110024102010002,112124042312000,101324030311010,104131002110200,101402001013023], + 1120010232022002: [110100200030100,100000411231000,140300020110000,100003301030120,110132020031210,100101004230030,103044004034040,102300231000210,102412140201410,114034000012210], + 1101013002130000: [102301031000041,114210002340104,101013224010003,110110131010010,101012104214110,100400122200034,112000202301020,103140120120101,102031004000320,100203220431202], + 1024110222041042: [100002004303100,110130010102101,102000041101100,100042004301301,100012021031014,100000201032010,114010204101202,100404000020000,100010210410420,100020424102200], + 134001004220200: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 1042201230202413: [102102031320011,102042031102112,102102031403230,100041140201301,103021004022022,112122334022424,102300004110122,114000202300004,111103022240110,100022111001013], + 104000031040044: [110013202003320,101031241000010,102120231343224,110030332100203,100314114322101,114404232310120,103100034001310,114002202210331,100031301020100,110111032140220], + 211004110200000: [100000211041234,101130000023030,101221200010202,102100014031110,101010101034002,100040001022001,110034030120032,110004342121110,114022000012100,111213000012124], + 1121304220200013: [110222140404112,100402020024213,112400204022010,101012400322002,110410020403024,103023141400000,101001100300012,100201020442101,101044021001402,114042034010020], + 1120412101104010: [100100124102430,100000240122202,103112041441211,114121224001011,112200042021241,110242012041100,102300020212402,110240230112240,100102104232420,100400040020412], + 1024031211314001: [110010200422102,100000011211210,103100024030204,103031040122130,102101021400201,112110200433212,102110014020400,102343000224001,110104011122301,100030041220222], + 100202010004001: [110013312204132], + 1422132110000010: [102000004002101,110202000000310,110000010120043,100422314300200,102141410230020,100042030120422,110020001224021,101012410301010,112100000200031,103120001400003], + 120103122400340: [114200212322001,100401210020002,112210322040121,100402042200000,110001440041003,100010111022102,100220300410430,102000224000000,100002104302110,101022440300020], + 1010300233111023: [102112104001220], + 1022132302041100: [101022014222024,102103430210003,100012014300120,110100120400020,102414014022212,111311002224001,114030000030012,112010024023002,103242044020102,114231032340010], + 100021304133021: [103120010103002,102040310222200,100112120404244,102100421412332,102242220202120,102122101340003,110420000002231,111324314134002,101300200311010,101200010301122], + 1011013421004002: [110241142024233,110441140102024,101001421031220,112300421134001,110210301200101,102033124000111,103021004014220,102200001002100,102210101121104,110010324410130], + 210320400230041: [102000140200220,102104231340013,110033032100000,110011002100114,102012001130103,102240044042003,103303041402240,100000020100000,100100020021020,114023102300012], + 1041002233112000: [110400124241011,112104034022022,114233300214304,111020204112021,103022444011022,102101101021304,110210000000040,100031324100010,102202000232032,100040004202102], + 1212413032110343: [110442104221030,101224001202324,111211144101202,100002001024100,102103130221330,110000300140010,103102134001111,102011310202304,100003114100011,100002314204210], + 1100021003100400: [101042410301221,110432300102000,100102024100020,102304000210204,110040344210011,100003320401100,100020120101000,100003200020112,112143144020012,103231224012042], + 144403431442201: [100003414100400,114221004002212,112010022302321,111110420014032,101000214211011,102300131102000,100110204101020,100000001020034,111322242223400,102101001412044], + 220020102410001: [102400111402142,141030301403400,100000024100211,120020211120020,110230010010142,101302101002110,114233112330324,110030211224203,103222414000312,103221220100201], + 122011002014310: [110430101000310,114000322300011,143310043400402,102200114042333,103101201241421,100210101003122,114441004120303,110000022011224,100000330000200,101012220320240], + 1042020021012132: [102022004012201,111130210020000,111102042213043,100000024210130,102034221103124,100034024104211,100014030200221,102041320220204,100020134212021,101201004203204], + 102120204200012: [110013202003320,101031241000010,102120231343224,110030332100203,114404232310120,103100034001310,114002202210331,100031301020100,110111032140220,100020010200022], + 131000034111032: [111021202200011,100001010100220,114110004102301,100414031001210,102000004012011,114023102303000,110101100012002,114421002320003,110001002004240,100030220002102], + 1122311210003213: [110102224201130,103301201402204,100021020124002,102104131412412,114020312300021,102400204043012,114042014014024,100000000200102,102014040242202,114420200001202], + 1120023302141322: [130310130330100,101231031400202,120412000041110,141111210002414,131130010401211,102111000103032,110231402124034,102000444004121,100400100013010,100401002201241], + 134024004220000: [100144100410414,102022001101400,110232400010300,100312030012210,101120204202002,101043021124401,100003010000000,100000404100023,110014301320111,112413022010030], + 1001033402010024: [100020344302010,101000024004442,100002100000100,112004302004223,114100102340003,110130030020000,100400032200141], + 112434100030022: [100003031030034,101001044211204,100031034311401,102100010233022,100000140100020,103001324000110,100002014200021,103211014030010,103212320212011,111010024402022], + 103010120124313: [111300232202103,102301401002404,102012004010000,100040324331403,102400100220000,102001104012021,100242444300104,102002104014323,100401241010122,100010010102122], + 1431013400220000: [102401030231212,114020012211143,100014011034234,100002110100031,100230112110132,114220414000323,100110404103132,102100010232001,100000324303120,102433214043112], + 210021210000001: [110000402130200,110210002110430,103024004010134,110102204202001,100141101040123,110422420030000,420011043004003,110040002032114,100120414100102,102404224041131], + 130041301113140: [101003024212403,100010220101010,102312004112400,103303004022010,102301020241301,112100004041242,112111040201200,103201010110301,114021102302020,114040032331113], + 1000144002110014: [110041030411301,110001041213031,103301210142043,100002024200142,102411000200000,100400014321101,114100122342002,100010101020023,110033041200104,102000221442214], + 1020410000130221: [114213134000203,114300020001420,114001012302043,114133230000102,102400100202230,100001021030011,112410220202110,100000010120003,103141210104024,103200110102141], + 1010241131213202: [102301344113012,101231211020143,112144220201011,100002131020410,102012214003000,103234000104020,114420102322024,100001001002322,114003012210001,102004121130412], + 1020023122120010: [100002000004200,103040000100120,102030324002210,112023102304030,102301030241010,114221004110220,103000204040334,100114100032200,101230321023001,100000400003104], + 1200212320001032: [100201141200000,102003431300000,110031400020301,111001312234300,112112000201110,100223021000240,110110412014004,110014204201000,100030120422020,111312044130120], + 100004242014102: [114101020033111,114410042322022,112202212040211,100331101004300,102124230233400,110142301120031,110101024400320,114211224002144,102001441133310,102212140200424], + 1002000130212130: [100030401020131,100020344302010,114100102340003,1204002112200213,111214004444320,114024200040021,110112001300220,102013210240010,111024132204021,101002414004140], + 101303320210002: [114040114100221], + 1004232223002210: [102100200234203,110001214200042,112002242001000,100021111211003,100010210101012,112010204003014,110134011000012,101032240320040,112001302302020,100203331000130], + 1000040404100111: [100040134340044,103030411422014,103043334040203,110422201312402,102120131401230,110302011332024,110200302024000,110210020104031,102041210224224,110240411110010], + 1401404020211000: [100144101000002,103220201200131], + 1011012040221310: [101011004212201,110032022002020,103031234000122,103230011412301,101042001021012,101100104002023,100400000010020,100124021201021,100102001000000,101240404044020], + 1120011230200210: [110202012100020,110013202003320,101031241000010,102120231343224,111342020011220,110030332100203,100314114322101,114404232310120,103100034001310,114002202210331], + 1012022044000112: [102040431121110,101221020040220,114111100021420,112024212301420,102212000200124,100300310140241,100240134323001,102042000222002,100030010102102,103312241402001], + 1020012401200231: [110011022201012,101022000322012,110103220120221,100101114301402,110123000122000,111322402200000,103300101403212,110421412110202,100200001000040,103001004014140], + 123401111214033: [110320414420310,110100100101041,100420124100211,103010211222002,101040120320230,110013021300010,101043234000412,101220000040002,100422001002123,114010010010002], + 112444420100221: [110300120403013,110131002010202,101010010320020,101120101100112,102410124022400,102300424112201,101020004001002,100002030410210,102231031123103,100030031220030], + 1001410442111100: [110101210013000,100404121014002,110120020002304,100011000202214,103040020122332,100000024100000,102102304001200,100010040001210,102002020220000,100102120422002], + 1024013000140000: [110102042010220,101020124000413,111210000001101,114013400011030,102202000201220,103004104010210,101220024041000,102010300201414,100202200003011,114330432320002], + 1000211120031000: [110204004430204,110300011230013,102100400222242,102122114003140,100002021032001,102011404010000,100000011220004,114111002340233,110000210004001,100142121011414], + 1424133111312010: [110102042010220,101020124000413,111210000001101,114013400011030,101201104040034,102202000201220,101020111030400,103004104010210,101220024041000,102010300201414], + 112132120131101: [103011200100000,111020400040100,100302000140222,101031320320042,102122340200200,114000214021240,111111000020023,101311111000100,102400220203010,111000000012202], + 1003003210020004: [111103402241002,111200130011000,101222414013042,102210044003121,110202432243230,100140104230112,111202132210400,100120310112042,110020000110130,101202000300400], + 112104010210330: [100041010003001,130004114102103,102001100240033,101243220304022,132220114023343,110000011231142,102303400133033,100130034000100,1022020221130104,114204100213041], + 1010001221201024: [100031034311401,100023210021210,102100104000203,102000200200301,110200101200402,102021201410011,114013124030022,114104200220022,103211014030010,100034124101023], + 222031420110402: [100001220400300,102212001103340,100002334202400,101222401020120,114010202211102,100023004304344,110220242131013,102102010214104,110211030000131,102222312020011], + 1001103203121110: [101001421031220,100021004310222,112220322030220,110313312021120,111000034110311,102200001002100,102000024010002,100202000433120,114240422320041,103302020111204], + 101010133001340: [102002014000220,100002011042020,102010200221000,101041201002422,114402320000202,112000002000420,100240101000030,102012401001012,112431004013030,114003002301122], + 1022223410030103: [100023324302420,103111201422013,112203001103411,100212024121000,100001001033200,102304110220101,114002004100042,102402114000021,102001024012440,101222244040420], + 130411030000022: [110000204210130,100100100422103,110020134410001,103101001422002,102204004042041,100021140000322,102101002004300,114100202200202,112000020210140,103230410100410], + 1410004201314301: [100321004011041,110002342100014,110241024242442,110021312002040,111101042244210,110124002040002,110023410122402,114302200014241,104132420010010,100001041031013], + 1121122214014040: [101142400332243,110002001321022,112022002000012,101401204021230,101012000342400,102041201123423,102121014020030,101020341030100,110002034410423,102340201100414], + 1120020340001104: [102000011122000,102302021000041,102110111410032,114002100033010,111000000043030,110011021320030,112002101120233,141002100010000,101402114020000,111411332102004], + 110012010002010: [100041300102040,101204144232110,110000122010022,100120121014401,101040014002222,112343011130000,112000340233020,110204214241002,112200322024213,102100130311000], + 1110022402220300: [110210400114203,100001100104021,101101300010301,101122200300011,112210201100012,112001122302311,101001211004233,102303011002000,102314100240010,110312020400202], + 214301230100000: [100102011010403,112021024004034,114030422211111,102343201103202,103343324020020,101020001032034,114000102300204,110330204422022,100000104101110,114200002320302], + 131001021020030: [110202012100020,110013202003320,101031241000010,102120231343224,110030332100203,100314114322101,114404232310120,103100034001310,114002202210331,100031301020100], + 1002100101403234: [110202210102120,114001004100003,100041014102004,110320022101120,102131421000411,101412030302001,102222021124112,114000040031021,102400001110113,100404201012020], + 101033322422021: [114003344011001,100021101000000,102334021001211,101203001010111,100031201030102,114201104114111,101041001003300,100001100411302,101414214021020,114123420002142], + 100020140020112: [100000110410000,102302211100230,100001004104043,114022212300211,114102010223100,112014402034232,102002104004011,102102104002322,114222422332100,101003011000111], + 102304313032002: [114012012330203,102100020211003,100000214102101,103100124003243,102413124042401,102033200222311,100100104102000,103332430114042,111204302220322,103021024022122], + 1000320024241110: [100030231231021,100012004104000,112204231100020,102221201300200,102221111111011,111030022230323,103200344020010,114114224003240,101022410324200,110002002231202], + 1004121110001220: [102121221343020,112104424022201,1302314034023041,1300034431310021,1001010233020100,112012200120020,102210104000000,111023100040110,111041134000211,102203211104211], + 1224331430021213: [102420044040023,110410202122004,101004204040210,102332331001100,114022014010344,100120404300300,100021104314210,111023304123001,103000001400001,102400021111004], + 1004200010332100: [102102010214011,103112004004201,101040341113030,100002031210114,100014144300334,101020304004102,100402032201300,100114004032011,102204004030201,100401324321022], + 1424000111301100: [100010424101430,114000224101044,102110022001111,101020301114001,102102300210103,103024011431131,101011324001431,102320200224120,100030014210012,114100300000120], + 1103211204003410: [102003004000040,102011101131021,100021100013401,101242421020211,110310042021341,100204011000000,111010110042210,100114200020220,114401004122120,103123200101000], + 210140042111114: [102000404012021,114040014102222,101213110301210,102043234004101,102204414041020,100400300010122,114130342204230,100044021222203,101010000321000,102003400210000], + 100121022223010: [104100421240110,110024042103114,101001101031102,110001040022210,100230114221102,110041221200014,102202121300311,110301122022204,102420101400213,103104010100031], + 1012000300022120: [101201200310001,102020000201200,111232000010230,101230000302304,102300121004102,102300211000020,110222100011043,111322224120002,101020320323422,114220200214400], + 1100010012244110: [102400040202040,100102011010403,100220000144000,101022344001121,101044334010021,101314041002010,112021024004034,114030422211111,102343201103202,110114140030310], + 1030003421104201: [101044214213201,103121304001014,100020024101221,110242110001231,101001224044120,101000404000400,110414001210110,111100004104000,100113000410220,111141232221300], + 1400000121040102: [101020024001041,100200201000001,112224232044014,103032004012111,110131022014120,112000002000110,101322221001300,114421204140122,101424044043122,102112014000403], + 1010142322233320: [111010204124220,102030010224202,101021334000001,111142000010114,102220241100202,100402022200002,110103320400030,100401000020423,103143111404003,114213014030342], + 1000044000120100: [101020100300420,100042034200032,100200021000412,101400240300010,110330000400112,110000000130104,110103041012020,111233314101101,101122420322200,112101100221122], + 1000000000301000: [110130314400100,100032431030100,102022004010240,102023211411003,102340200224222,114002014033200,100004301021110,101010124001000,102111244000012,100400000034231], + 130012020321030: [102101210213220,1340021101022233,1001013211040100,102220300000443,1132012124324031,110210103122411,1220440411222303], + 1000020002322230: [114343002322014,100022314100104,102130314131401,114100022342130,114300010002100,100013024312024,102002020243020,114002002300201,102040021121030,102102211140013], + 1040121003022002: [101403014020203,100402004300002,110003032000041,100112000410320,110124044400220,101210211022100,110421202110000,102111010200000,103002110114402,100100121010222], + 1403411023011102: [110110011340130,100210304330211,111121210031101,112312022021021,101041010324010,102104210214401,100011230101432,100032024240322,103202224024200,102130031410200], + 1123440204100404: [114101024120020,100000001021013,100011204300012,110032220022103,102302340241312,103243130100004,100030414311102,100410410002011,110133000404002,102202000200000], + 1031002421002003: [100022041001002,111240340004003,111101222244030,114032424122040,112011012004300,101021401003220,100301020420101,102002202000000,100022024100041,102010410213111], + 1000032002032240: [102202204040010,103333040110114,101022200343023,102000000221222,101320310311403,102011014001111,102331201001140,102101001342004,102103001414002,102022011101012], + 200322444411400: [112000112000031,100142104100403,114202204113222,103200224020100,112024000213011,103013024002104,100103030001121,111000004400110], + 1010300220000330: [114202200000200,103000021411202,114120014000103], + 311120230120020: [111101034100200,102001140221330,114221122320002,110000100442023,114121002310033,103300101403322,102201111110002,100211001000020,111202102223103,110000100131010], + 120202342410413: [100023324302420,103111201422013,100001001033200,103201000102140,100033200000420,101330104221320,110333034433002,102343044111203,103231001400100,100112034332210], + 300001042040004: [100030231000344,112311011101001,110100124402042,102120404134413,101100200330040,110040212000010,114102124000200,100100221040404,110211202030440,114440012312003], + 1021204000430123: [100103301002044,111130202220102,102020400244030,100404200013100,100040104331012,101114024200021,114402102312001,102240041122001,103204001200221,114244104111440], + 1222441104201020: [110011202100142,112400102013231,100410100030221,114410102321111,114012002212100,114203110001031,110400112210122,112030122000211,102023424004210,102212110210401], + 212000223010102: [110202032123210,111122004100020,110412244220110,102411314024401,114001002300430,110101230100001,102200034024120,104102130014402,110314042102142,111120122242010], + 1012403241003002: [101221422120021,100231114320100,100001000002210,100400320033201,100004130002301,101210300302302,102020131413423,110020204200342,100000220011133,114013012240011], + 1101010400000100: [102020440242023,100220010002421,111210240010100,103222010114132,100110004332200,102430001110014,102002101410204,102000004001020,100011100412123,114401230002424], + 1104301232301440: [111320200011200,101030100320211,114000300021012,101141114003000,100042004200210,102330004110401,101400401013424,114012404102202,103101011210020,110402032114001], + 1200404130401032: [102302340241312,100410410002011,102101224002210,110311232120010,122203322100011,102010010220014,110330022021224,100410311001021,110123442011041,103021000110211], + 1000204000412003: [101022014222024,103114204002100,114230004110101,100001101033010,102142002000030,114000024101202,100100014302013,112020021120403,100002114104410,102130314134001], + 1412001330222001: [114122220031001,103002221240241,111043024121020,114104404002304,114102040034111,102141002000420,110431301241000,110101021000023,101000304013204,100100130003000], + 213210041001200: [100140201011204,103010014013304,102103030201001,101203104200224,100140000024021,101223024200014,112240404012020,110110210012111,102000220204011,101201024203004], + 200310002322010: [111000240044102,114402414111240,102111211401000,101030411001300,102040444014121,100014204101020,102012110232021,100002041040430,102002230200001,102004004001010], + 120103020011000: [114004142244000,102002004012310,102130034023112,103100001422200,101330120302103,102111301402121,102010310211212,102210104011024,110010004202402,103002104011000], + 1121001201034201: [100111011040002,100302000140222,114003114024220,100041221020214,101311111000100,100040341021101,111123212212000,114210002340000,101200221011402,102221011011030], + 1042003233402010: [102001231413224,110220202124002,102030024010020,104100212101210,111320000001004,101004204211203,110002012000001,110304000402222,110201002040204,110010402102122], + 231030030400001: [100440104303400,102122000214201,102220241100202,102024240221040,110320011200230,100342024100204,101422034042201,100011114300334,110040122000002,100110201042101], + 1002210020110421: [110011232100412,110100100031014,102401010202301,111110004101041,102112004001032,102212034044212,100021020414340,114101212202230,114100010002210,102000241410040], + 220201011004010: [102041100200402,112100404000230,110400112021140,110112121002403,110122221240302,102241230200120,110201111200204,110400104222012,100000001034120,103302024010240], + 132241324340300: [100244210140341,102024124000001,110002222201000,114104300220204,103102321423211,102121300201244,102101200231432,112000240221140,100042000010010,102000331132232], + 140330130401201: [100423004302232,110030220000310,100110034332223,101223100300200,102001034002201,101100011201440,101104401020410,100113004304010,101310311000124,111303214132004], + 1044300211120142: [102301344113012,102141124004222,102430201110000,114010200020312,102124002000102,101343331004220,112042422001032,100011004312001,100111200414020,114044414023030], + 1123304221013002: [101211020302000,102420034022021,101100121020020,112102000423104,100004400012402,103300001402313,103001430122140,101123011102101,100401300020101,102021230202032], + 120000300200443: [102021024000010,112011012004300,102300010242330,102000401120420,114011102210402,114300100000041,114023204100222,102222014011300,102101430203000,103030204010001], + 112323221032310: [102304340220231,110420104221220,102103440200402,101014424224002,100043000200103,100142401040042,114001032302222,101013404210010,110230000002324,101401304040214], + 1040241210400042: [100012120201211,101410044020102,100004210412101,102011014010000,101420031011004,100000014310020,102111001341321,100022204300002,102202122000302,112100222300311], + 1002001420000321: [100002100100210,102420424042020,100010001032223,103020031403100,102200401111200,102000430221040,114003104031111,100100000422320,100102020411200,102100012002000], + 130011001120203: [100422000031421,110302040102004,101032000323012,101402114042420,102220021120430,111341300012200,100102000010243,111302304130401,100024334203210,103031410122401], + 124202200022300: [100021234303000,110420020103322,100030101232000,101140030330020,110030242131210,100340204211100,110203200013020,111101202242012,101400430300211,102010311103102], + 1120342300121001: [102022004012201,100000024210130,114201224110141,102034221103124,100034024104211,100014030200221,100020134212021,114420022314022,112001120220130,101040010321004], + 1000200020301202: [102023324010020,114000004103003,111131002212014,102110100233222,102120311402124,103140124002022,101042421021120,114013204013220,102000100221400,114241204001213], + 110111010221120: [100440031001120,102020200223310,100020001041410,103220011420242,102032012000101,114014112302234,101004201001232,112102102302000,102141231343401,101231104200000], + 1020202000004242: [102024401440202,102110021342213,100023014340130,114214034100221,114202024111304,102200204021004,110200102020212,100041430100100,114112000000100,114121144001400], + 101423111412020: [112004202302034,103300004021200,102122214131011,100023031000024,103230134011412,100012004101221,100020004101012,102311011000200,102021021101204,100231020102202], + 140211103041000: [110011202100142,102123411402002,101042201030422,100410100030221,100002001211230,114410102321111,114012002212100,102120204130110,100023040002011,102302114113421], + 1002121200421203: [100011440000101,100021414102020,114103432340303,101021411140012,101202004200131,103012001241030,110200240001240,112242200410103,110200002020114,100002440100200], + 200424200100140: [110424002022221,102000140200220,102012001130103,101120000011032,111011022203204,110202000403003,102003101131002,103102014030320,103210031422000,100000131230300], + 1000444001001240: [102041310200042,110301030010140,104100002101431,110221000111302,101010001002000,110022140120012,111330020002213,102011440201423,114011212320331,100002204310140], + 311202303020014: [100411024321140,103222210111002,100002004102120,101200224010201,112000401122102,100003404344101,100022011021013,112433200202102,102112012001422,110212210121023], + 1003111420100210: [111201032220400,114203000004300,100022120412132,100000321031423,110322100104010,114043002302200,101222121020001,102120230230000,100032021041010,114100004121121], + 100400202222312: [110104112010103,111102004100101,100122004300410,102202414041044,102000104012232,102021100220101,114443330001442,100230120001003,112042110220004,112203221102231], + 1432222010100001: [114213134000203,114300020001420,114133230000102,102400100202230,100001021030011,112410220202110,103141210104024,102200100204220,103200110102141,100021030100001], + 200321401023113: [102130034023112,103100001422200,100003344210120,102401001404214,102121024000114,114022004021013,114001002300121,111220210022140,102002244010001,102412301400040], + 202100001410010: [111102012220413,101101131132022,110010102132024,104120211242040,112220104002000,102223004042102,110410312121010,110330130010041,102422200201100,100432121010201], + 1101223420330001: [112210104000224,102302224113320,112441402014033,101211120304230,101123210321002,101003010340102,100022024212302,114104002204400,102030001134340,110001010130320], + 1004012010220044: [102141000230042,100120221021011,102002000221000,103220200100320,102000230224024,114000020034200,100010001040020,110200440000121,112400204040200,102200014114300], + 1420102240203012: [110120144200000,114022412330004,101200221022044,110241112020204,100002004104004,102100224000210,114201104111034,102310140240012,100014204201000,102103321411004], + 1402320420412004: [101000330321020,100102321001302,100042100200210,112240330200110,100114010023242,110244014240010,103103400211221,102100401400123,102200011100023,102003034000312], + 120002332420030: [111212022200012,111412020003222,103021020002400,103031041402200,110010102002310,103004041414132,110302242202220,111121004402312,103010441402001,103221000100141], + 1112121041002400: [104130302103001,100000040401014,112423314020341,101000024001002], + 100201434213010: [114303202300104,112020044000400,102100300233312,103041130110112,100400020010210,110023014202232,102020020204201,111214020002001,114011122301424,111001320002031], + 1001222041030043: [114034220041220,102102231400111,102100422004010,100032421040120,111100232241200,100024004210111,102002100222202,103343010113030,100031404302400,103200234030122], + 121100100114422: [100041001041330,110220300003442,101320214231000,114442130003202,101240200302230,100220400010440,103212034041210,101430001013400,101400111112122,100402210022301], + 1403412101102300: [102100201440001,110400011311001,103300120141130,102110004000221,110040002132020,111144202220301,114224204100310,100000000120200,101434031010012,102304011004310], + 100412200420010: [110220100000102,114042102330002,102102011414242,100041004100221,100014001041000,102310030240210,110000010033022,102210000201040,110110122210000,102200400234000], + 1121320100221414: [101100011102402,110012220442042,100001114303001,100002020122000,103001031403201,100034204311021,110033020003012,110023100420044,103332211400441,103011131430040], + 200030200402014: [102040431121110,100400002201113,114111100021420,112024212301420,102212000200124,100300310140241,100240134323001,102111024000402,114321002320001,102042000222002], + 110230223200411: [110230301102143,111100210020023,101400240300130,114000322301211,102222202001003,111200000001000,112040020224201,102332210244120,103002004032001,110110302214004], + 1424140032000000: [113020102210041,103042144040323], + 1031020000041111: [100000034301140,102111011142022,114132142312022,110211130002000,101420000330441,101040111003030,100400100013024,110140342044321,102213024031310,103010410104400], + 1112202301112040: [102302200210010,102340120222440,112202000411103,114223204100010,111041202200140,100023014313010,101040100302002,102011314000200,111114200024112,100000020202030], + 101002200401003: [101121211101004,101114101012020,110002002000100,103013000104404,101001304001101,102041111020030,102011000200113,110022001201023,100000040001141,103101124003110], + 241232403110130: [110311002102104,100410204303320,102010420220000,101000040341000,100001024102000,111330004130112,103002311240000,100202144121213,112001032003010,102010020243104], + 130021000200100: [110000101304203,102130020200000,110040020001022,101104020300301,100401241014100,102101004000011,110023330004130,101401001010021,110033002000020,101200200300020], + 1134110400102221: [102022010240041,111121100010041,100020000102421,114202002324000,110013024201420,100004014202422,100112104300311,114000004102342,100002100021324,112001200221123], + 1042320112200000: [102240020200400,110020402002000,100042111220111,103310421404111,102101134004010,103240100102101,114100042311200,101010001000400,114002114021200,101020231000000], + 1103042023022003: [114400022321400,101302340312230,100011101222101,100030411042022,114304212302401,100000014201221,100401200010140,101120210300322,110200030001040,101001040311000], + 113121000100020: [102114000220010,101004030322001,100431024302303,110231211300200,110040044201303,112210304010130,112004020202021,100034020000002,100221424220000,101110311041004], + 1100004111030022: [111110034423202,112014440221201,102311010213330,100021024310204,100022104100032,102001024002022,101003004212410,101000004214010,200224341002234,102412300230420], + 101313200211200: [114040300043111,110203111111000,114010030024204,102010201012014,102041204000002,102323204112320,100402201004014,100420404320101,102123414032304,110420220003321], + 103214400003110: [102312101001340,110020000110204], + 100000002334231: [114010204101202,100041234101100,112204220200011,100000101024211,100211211002001,103210004031201,111231012242301,114114100214000,110010220040013,101104320012044], + 100322100004201: [101041301000320,103242311400421,114302200002200,100020001224324,100200024301301,110010204412200,111202010001410,102203041122004,101202020300403,114001210031400], + 1004030230310002: [102101021412120,100003014314102,100011214102010,102112241342203,100002004200212,110010332201012,101010404010000,101000411001330,100033304210223,100000011211210], + 112222120112221: [100113220020101,114031000022030,102014002000401,103103241421322,100300211000020,102104304023201,100002224244002,114310200002400,103211220100010,101202201021310], + 1120400021000040: [110001332120300,102101211411000,110003000420200,110243234240200,110004014411012,112000120232022,102041220200010,100002320113100,112240200202201,110020321120011], + 110300202220101: [101111140300020,101240301000140,103034130144031,102140200212214,113013120103104,114101320030004,112141320423240,110220204211003,111200142223240,113201230210100], + 1000011310010300: [110221204243141,100400220010240,114102210220100,100000010004124,110312300040010,102020200203443,102102001402012,100124221021011,100012200002000,114012002304110], + 320130342401300: [101200341010102,103124210100201,101001021020212,102401001110000,100131011001300,112011300223041,110220002041102,102200100241120,102030031133201,110032232131000], + 113340030210040: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 1120320130021143: [1000200022121000,1320120012403100,110110022000330], + 1000312101023124: [100002100100210,102420424042020,100010001032223,102111024000402,114321002320001,103020031403100,102200401111200,102000430221040,114003104031111,100100000422320], + 111313120002121: [102101021412120,110024020421011,100042014310200,100003014314102,102100011000033,100011214102010,102112241342203,100002004200212,110010332201012,101010404010000], + 101004113044212: [104120011242011,114300000000002,110020002104100,102111400202120,102000301101102,111400214442024,114100124002210,111122200021102,114032234033303,112400034040002], + 240033120420113: [110000000003200,110200000004322,114342044032200,102041100200402,101100401022000,110400112021140,100400000010022,110213140003121,110000002131031,100020001040103], + 1011000144402210: [100322100143040,100030240102022,102303320221102,103311034030000,100020414100300,100040004102010,100013441022002,103300420111302,101002301003030,114020412332003], + 112200333201104: [110212022124220,100003100410042,100222034340301,101440044041401,111210012243010,102130124000000,100032310000111,102010421413322,102114020210302,100001100100040], + 100341400104101: [111223402220443,100211120140002,101010201030113,104111021244202,114033000032021,102401004043011,102100001444023,102223134010120,112002200201220,100300001002041], + 1001412420120310: [114043022300023,101020021032101,101003411140003,114304444003432,111000014110020,100212031002000,112002004002011,101040021003100,110023341031030,103202244021110], + 201014130212002: [102300001002440,101011020320030,112202040411432,112130004043234,110013020024300,112101120201010,101000224223002,102010211120200,112003202000010,101224011011414], + 1010202003404120: [100144101000002,103220201200131], + 231113102311022: [102334224110044,112430304044242,124230402001402,110001044200004,100102001002010,102104111121123,103411204001204,103010124004030,100121224230200,101402224041012], + 100021230024032: [100100021040144,114011114123044,114101404004011,114142044000010,111230032242001,102101404000000,103230004030322,102300200221021,114322222322000,100104020022212], + 140112103012403: [101220112203201,100223421002014,100121004100012,112104024020004,134113234320032,102000024012122,101013000301230,111014034121410,112200224042000,114011424010010], + 1201022020141000: [101010224000130,101000414002041,102322004112023,100020140002030,102010420220104,103022301400010,101101020320132,111302024132000,111010104411012,102201100230001], + 302333200211020: [102242304042410,101001034002001,102000201131020,1010120030012200,101024411001024,221104221024023,102123332000002,100202211200032,112243004012100,100142410401000], + 1000002020031020: [110210024220020,103101001422002,102002104011244,111140122114101,103230410100410,100012000101100,102142312001341,110020022102201,102120011404102,100003330100242], + 134240011004020: [100032041021210,110004301222000,110414300030001,100030020011022,114310000001232,111202012222402,102040041320010,103203401400132,103142111441040,110104002010100], + 100210302241104: [110120144200000,114022412330004,101200221022044,110241112020204,100002004104004,103130021444021,102100104002224,102100224000210,102103321411004,114113000004012], + 1031202410430003: [104100012102004,110021232000021,100401241014100,110301322104142,100001140000010,102003000212200,102420020204200,102000200222121,110330010012100,110033002000020], + 130021401200220: [110013202003320,101031241000010,102120231343224,110030332100203,100314114322101,114404232310120,103100034001310,114002202210331,100031301020100,110111032140220], + 1020002400310121: [101130404200012,104132020011100,100000111002110,100122104000030,103200130102024,100400322200340,112223211100103,110341000010200,110221000002200,110014024413040], + 1012410110111000: [110104112010103,111102004100101,102202414041044,102140014001101,102000104012232,102021100220101,100230120001003,114000040010421,112042110220004,112203221102231], + 1430433031402421: [100100021040144,114101404004011,100004414100021,100102404100430,103020241402220,102121001343030,100104020022212,102023110212012,102132210233141,103321000110042], + 100110032030213: [100011004340114,114300204032002,102000021444112,112121032014014,102102030210111,102000201011310,103300100110220,101201041010123,100120004300402,102140341343300], + 1003143213010340: [103302040111403,100030240102022,103311034030000,100013441022002,100020224101141,100010300201242,102104121340001,100232034333120,102200311122413,100020024300241], + 210100042110420: [114001000020102,101020040300010,100213001000212,100002004212420,102121014002022,100141404233000,101020001030204,112201232020001,112123300230240,100210001002101], + 1010431020002110: [114100402200003,101230034044002,103202014020301,102013021123204,132002230002223,110120104221411,110000320020104,102102214031100,102004144013001,100200141200210], + 1043001040000400: [100131110020124,110010000441312,110104140030101,112000101110201,114322312303022,101101400310130,103240304020120,102240130230402,110012120141100,111000220000000], + 120410310011120: [110201201211024,110221022101104,110123004401121,100040341020133,111101344104210,102203031121210,100410220030300,101110020013040,102032124001120,101021204000200], + 1410224130410310: [114201204111222,100031001020040,100104001041200,102012200202303,103300004021200,103222114034232,114210400000112,103230134011412,102112222001200,100021104100310], + 1110024113020240: [100021000104004,100002200022012,111140204103210,140004010302423,114200320003120,100200113201000,141220400002200,100044231103400,100411033204412,110000001210210], + 1001132101102313: [101221020040220,102212000200124,100300310140241,100103104302044,101041030320401,102141212000200,102042000222002,101203121020430,100030010102102,102020004000014], + 1400200023240011: [111041004113300,102020010203200,100011144312020,103110120210013,100020221040231,1012220402104110,102011204001010,103012004034001,102001410221023,101010111034000], + 1002001400324202: [100032041021210,110004301222000,114310000001232,102040041320010,103203401400132,110104002010100,114142044120310,110220410000040,101030004010034,102201411100212], + 1100020200040100: [100031300002022,111012002200101,110210022120040,110000021221134,112203412020010,103002044002032,100101020402424,102201112000001,100111020003101,110420202110100], + 1022340221034300: [102311000212220,114100100022224,100003144300223,102423221401120,100324311003242,101430021010144,100200304102211,101012311113131,103022120100040,101004224012043], + 220310002340110: [111201312241430,112120200204001,100030024301424,101011114210004,101211020302000,102420034022021,100002111231143,100102104102133,100210410102144,100103400000201], + 140340430110040: [110220122044010,110042304412204,114020124021122,100002201003312,110110111010042,102230121120000,103300001402013,100400010013330,102204011110020,114042244102400], + 100301022000103: [402000401204030,114124020222032,100140201000222,110110000004210,101400010303002,104200202141001,130030220200012,112200110000221,1321002023100013,1103040030102440], + 1120100002021000: [100002131024210,102410001402210,110000102100012,101004200304221,102010020223010,102120214001422,101412300302220,110320002024021,114201200004112,114002044114140], + 203204120240002: [100231401213132,114210104113314,114021232300112,103001000120444,101144024000232,101302121004422,100000010011430,100114420000140,102022300241201,110200100001242], + 1140002301222214: [112124004022322,111120230020122,102103201320411,112124310203104,100100031043410,102001000221124,114001100024243,101010111033143,100021221024312,112020100202034], + 1013010401042000: [100043014203003,112332000411020,112230024010203,100000004244400,110024001211221,102012201441404,100131014234134,112000120241120,100030224300202,112202140201200], + 1110011230000000: [114033300040100,111320312222220,112021201120101,100001000012021,102010231120312,102300014110023,101021110322104,102100230210011,114003202304041,114420302320210], + 110022313300322: [102004414000212,102002104014022,102041324001010,111020240024110,100002101021040,114013324102022,100100100021142,111200112221320,100000331021022,101400314042120], + 1020210040230441: [102411111400020,103002100100400,100000014100240,114011222302401,303020114301043,100100030200200,102202144030212,103031204010122,132044134324300,111010111010043], + 1212020444010014: [100030400013321,1010213210204021,114101020033111,112202212040211,103020004000410,111100044403012,110004022101020,110142301120031,100001010404000,102032001030043], + 104230102200022: [103204301402123,103102224034002,111100100004430,102000000222203,101001301032024,201120000130201,100022431030100,102214101120310,100100104101020,102320014112012], + 1103030441430142: [103204214040130,100142010410011,101210210300031,102323201000412,102212434110001,100021020412110,112102314020000,114010002304030,103110000223000,103000210120000], + 132000020002114: [110300222104222,100002040410130,100440001000012,100403011002204,110202414214022,111002420031340,112432142020024,101103012130233,102320304030000,101112241010002], + 104232302212022: [100310014310311,103230004000142,102011114000042,114110024003013,114142102344042,114114040001042,100000030003111,103002004001434,114200000001000,114031122210003], + 1140111300200210: [100020300200110,100042000200211,100024024200032,221123404200214,101004140304211,100021024100301,1101210010010223,100000241033100,100000134100120,101012010303400], + 1112000002004410: [100100124102430,100000240122202,110010102234002,103112041441211,100410131001034,100400320022213,100433100431011,114121224001011,110242012041100,112200042021241], + 114121024420011: [100030220410304,114000102210140,100000300012003,102001040202020,102020430244102,100003004340202,100112324103232,100200001002101,100133210000030,103142211213001], + 1011140134403200: [102040431121110,101221020040220,114111100021420,112024212301420,102212000200124,100300310140241,100240134323001,102141212000200,102042000222002,114402104142102], + 213141000004210: [103241000112010,112020104001300,101400110300032,110032412204130,100101004300200,114101012201420,111032414402324,102424040202123,101114420310142,101120244000002], + 102020113001000: [100301001000202,104101112102403,114201432320014,110324020012330,120000002023011,101014020301201,100001134302201,101010111002141,100000140413200,114123124143310], + 1141040413110112: [100012024334030,110002002002112,101000001031401,100003104100022,111204014130320,102030031133201,114100340221110,100000221233001,101000114000003,102142034004000], + 110014421002320: [100021400101221,114100124100413,104130301242304,101001114012114,101141400302200,114222042332003,100002044101122,114020210010230,103342424024214,114000124014210], + 1000000210030210: [100110210024121,112220010202202,101210021011110,100020100200010,100020114202320,100400000033202,102012004000242,101001010321440,110011002014134,101001100320111], + 1042011430220123: [110024020421011,100042014310200,102100011000033,100002004200212,110010332201012,100033304210223,101023120301030,112102030200341,114242200000000,232421034234213], + 200030222210014: [111030212113431,102001111011201,110044320441241,102233034000002,110410122010102,101122404022022,112130004021000,110311110410340,100100200021431,112101202012010], + 1202030002011000: [110001114423041,102302014024114,114211020002103,102004200212202,100002134211200,103000001400122,111140220032112,103100401443440,103030010101002,103132104000440], + 1100004104404214: [102134133001030,100213044231041,114124130214200,111012030031241,100103244002044,101142001141142,100400202201440], + 230311000204000: [110000412003001,102011331131302,114000230023300,102021204013000,114400200004310,110003000024101,102400401412102,110424200100400,104021120012202,103211031422023], + 1021200401230012: [110403302023130,110001004204310,100010311020030,100020000200000,100141230020203,101031121003021,100200120030203,103111201443022,110101214400030,114104040220130], + 1113211221020400: [114231202331202,100003021234044,111102032220111,111300042200340,101010041032322,114020042300022,100021421020002,102400004040100,111120204100203,100122101040022], + 100011030020023: [101223214040000,100304031003410,100202100012203,110130001001030,100403300010004,100402420012143,110020012000204,100200001000020,114041002212000,112014000202040], + 100010430000200: [103100221440010,102140000212141,114301000000002,102424114020143,114012444020220,102023021321020,102114020210202,100040401020413,100000024300321,102114001342410], + 1411121410001302: [103223014033210,110001311210334,111403414421302,220321332020001,101100234021102,100002220001240,110100014401214,110440112110241,110204010011432,110232031200002], + 1000122404014000: [101232314010241,100301300121100,110042400130000,103020124010320,100021300101201,110230022122031,101000444214021,112102112301130,101244324043222,112102232300222], + 104003042102140: [100203344301100,101000110300300,111013104120202,103420104020200,101302034220004,110131411300312,110200124240014,102012110220300,100011011200212,114200024101400], + 1102103221003103: [111042000041011,112040232002301,100023124103021,114230000000202,102000000240101,102020040223423,122202200013331,101111201110101,100031030000000,110100321201200], + 144022300022023: [110401100400430,103143111443210,102112212004043,100144040410322,110103221143200,102320001001023,111033434402423,110020100110002,110001021304133,100400402200402], + 204110300110012: [110112110030020,102331414110004,112000322311331,104100122102020,114211140213100,110201030002222,102212010202013,103203014030010,112002210221333,100201421200224], + 1032002001040401: [110020102000133,100000204342022,102101220213001,101441101010020,100001214303000,111202322222023,100002004342004,100200100401130,100123010012402,100210131002013], + 111003332003101: [112003100241220,102204304000304,102204001121032,102004000220013,114130302313120,100102100000410,114003124010140,100340000140032,101110021040110,101000030322212], + 1103014102040010: [110011414240022,102202310203222,100042001020203,102002320220202,100010044300003,114130210231020,103301410110110,112114324040000,102124031023100,100204104320231], + 300320104021010: [103343014022202,102003104011000,102220330202001,100022200120040,103002020110334,101021134012211,102140200310400,102220130204110,110010002103002,100220034341000], + 1112244421004200: [110320202023400,111431110000042,100302141003012,102004441124110,103303201400021,114101420030202,114421242204443,100000301221024,101224322120022,110104422010121], + 123000011201001: [110330400010040,100101231004020,111000100012002,110022140120012,100143040411011,102404404004104,114002202302000,100034000000002,100400100031022,110020130044232], + 1120410122424403: [102102211400103,100244104101010,100200011002201,114022010020032,100211310140340,102221231304420,101003411140211,100100001000203,112200000410000,112121324020001], + 1120102120013040: [110011032010001,101001131021120,100000224343122,112011010210200,102310030202020,110020101010020,102420201112010,100002110000403,100242104310100,101021200342003], + 1001001422400223: [110202000000310,110000010120043,102102011413000,102403404004110,102122410220401,110021232000021,102141410230020,110103111120042,101110020013040,114420000001301], + 100120111000011: [102101021412120,110024020421011,100042014310200,100003014314102,100040224102124,102100011000033,100011214102010,102112241342203,100002004200212,110010332201012], + 1004041313102100: [101232314010241,100301300121100,110042400130000,103020124010320,100021300101201,110230022122031,104101201240100,110000011012202,112102112301130,101244324043222], + 1140200000302002: [100140101044224,101120004023340,103040031403031,101000211032200,100010044300131,111010130002222,102030021130002,110200300000010,101310120314012,103114014004102], + 1121230200040310: [140001210202000,112042112310021,114000402302014], + 1013122010400103: [112413224040101,100220100110400,101200031020230,102403004042342,101024001034211,111122004101222,114001012300002,102121100232012,114000222213021,114102330210021], + 1040002003040102: [103030000122220,102200100200401,111132002240100], + 1000100140400332: [100323120143000,100103021040102,102002210221221,100102204233001,114314102301022,100010311034142,100004414340430,101040421112302,100130220100340,102220112020401], + 104202022204010: [101000411030013,103012004020122,101322310313010,100000000410101,114403020000214,100003341020020,114110104121414,101313000312100,101210440300141,103234020104000], + 101001212002320: [101020024212042,100041204212120,102113110210240,112423424042102,100320431000002,411200101402221,100120214230002,102440100200000,103204200103440,100210004104001], + 104320330011002: [102102101412200,102403004020222,412010100222032,1000030331001004,411002200000033,101111220222002,110144110000000,114320100012003,1300000411002032,100424222031420], + 1100133304102024: [100240041002200,111220214444420,101000100310021,101014214000103,102102020312401,111042100001111], + 1003020100310341: [102000001132113,101010241003223,102000020220000,100000201041300,101100300302102,114011200003102,101020104000040,114412142320040,102104442004300,103012000143212], + 102412203001032: [111130112100210,102202200240222,110131044200121,100100004102234,110223332120231,100001024301322,114013044102010,114220114140122,101023021034304,110200210110130], + 1010100320042314: [102001444000222,114120014120230,114010314101200,101001201110100,100113201011032,102230000204000,103102044031002,102341014010003,100011421002120,101012320304101], + 100100311300032: [112213000200301,100003224334120,110204130004030,110202120003032,100322004314021,102343301100440,102410434000220,110110440020002,101101000330302,102020214010123], + 110032311122411: [103324221401420,110400332010004,100104100412020,101020031030240,114010004022201,112000130230100,114212002340000,100123314231302,103111004004332,102102010234121], + 1003214301411132: [114213002340022,120402022102021,102120140212001,114400210002021,103103221421013,102010002000402,100240011000013,100000021022400,114201402332241,144200203310100], + 124220201321101: [101221020040220,100103104302044,101041030320401,102141212000200,101203121020430,103130021444021,102100104002224,102020004000014,100000211023014,114144014122041], + 131000301033040: [100422020001001,111130220010103,110000204200240,103000330110124,111120302100143,112300131102102,112232104010030,102100010210114,100210304104040,114400232320001], + 1020040110002204: [100402200031002,102002030224001,102034000244244,100001224300130,100400300010300,114112220000002,100113314304120,110411420000411,110000001323201,101412034043042], + 234021210112030: [102011201101012,102300304110030,114412000003141,114120430002002,103020041420212,100112011040011,114033300041020,101201220300012,100401024300321,100102030423010], + 1142200130022002: [101004100320141,102330134110140,102214100240020,102010201321044,103204201414210,100000001233441], + 1020400120241044: [110132010032031,100200044102003,100110231000142,102420210200041,101312004211100,110010030101400,100432200431112,111022114120310,114003422242201,113331432424011], + 134014014242000: [102140304001042,100202201002113,101222044204000,110000121310000,103401234001024,112430220200100,101034220301143,110003122001030,101012124000101,100011201023204], + 1204011022131303: [110020412000034,100111300414434,102130204000030,100401240012400,100101024033031,100010020402202,114344044033110,110040104211120,112110404021000,114013002303111], + 1022101404224000: [102231114040010,101401211012010,100000000101012,102103120200023,101120211100120,102000424002312,100004000413200,102110000210424,100001100421120,102202340230412], + 123000001220212: [101023424210024,110123042010000,102430321112030,111113004102021,112101432300231,102242200201004,111141224102220,100100101040401,100012130010240,100203114324000], + 1020404001100010: [111320300014200,111320122204241,101000024000022,112030101110231,101000220301403,110100400020121,110011304200020,100021120002000,110003102131421,111014024112203], + 132024004422000: [114021412213020,110030002000422,103100014031411,110000300424304,100032121024110,111403100030130,102022400211311,110030400004330,100401241014100,102324410243220], + 1044200113312034: [101112404231342,110011401011100,103021030102410,110430314220010,102423100202400,114100212211004,100020011230424,100104234230043,102000034004310,102101024000110], + 210003120031311: [102041310200042,110301030010140,104100002101431,110221000111302,111330020002213,102011440201423,100002204310140,110110210011002,100020320002000,110410014240001], + 1220400001122021: [100321004011041,110002342100014,110021312002040,111101042244210,110441010002400,110124002040002,103110314000100,110023410122402,114203104001000,114302200014241], + 203400134000221: [100032041021210,110004301222000,114310000001232,110220410000040,101030004010034,103100104000121,110024140142000,100212204243022,100321001001010,100002111020202], + 1042231103302204: [100032041021210,110004301222000,114310000001232,101030004010034,103100104000121,110024140142000,100212204243022,100321001001010,100002111020202,110321302022203], + 1103012110120014: [100022041001002,111240340004003,111101222244030,114032424122040,112011012004300,101021401003220,102020004001311,100301020420101,102002202000000,100022024100041], + 1000310201220202: [110202102121414,100002404310212,102130004002131,100430324300003,114230222331120,110143020121321,102000414010131,110410300402321,102120220221022,114001122302202], + 213040400030104: [101000410321210,102001041100103,111102324104110,114021004100002,101300201001300,102100221400312,102010101130220,102304331000110,114000100041333,102330324110001], + 111010044221000: [100022200410030,112202202042410,100004011024411,100402000013020,110010222101000,111204104100100,110000112030000,114231000212000,100000101030000,101024011034110], + 130300000221321: [100003211020020,111000240044102,100000101040120,102300000220000,102323320240010,100011200100023,100010044213301,100330204322010,102111211401000,100122124300402], + 1222432202200100: [100403200030000,102330130243430,112021400230000,111344004132104,110021110013433,110201010013331,110104120000112,102110031144222,111100024421114,101042301031100], + 123311231000302: [103100000124010,110030414202400,100202304341102,112203242043001,100001020000000,112000132000020,114110012310420,102133004000220,110000044200311,102014010220300], + 1024210012010031: [100011201020234,101221000302204,101040010311213,114100200002111,101000034210022,101322201001022,111212010004002,112420042020110,101022310300133,102110120210211], + 131302021043202: [100032041021210,110001041213031,102300324010203,110414300030001,100030020011022,102040011121100,111202012222402,111322234130000,102040041320010,102402104022000], + 220210111042222: [100142040020020,114021442210441,102030021121310,102202010232020,102010104010120,114230200000024,103100434003101,110040200022100], + 1001021023221222: [101004120224442,100413311002132,100320421001431,101233021020010,111131102210013,110400241240242,101001024210000,102000324010303,114002020042033,110023102103200], + 111101122002221: [114400034122341,101444024041143,114121002310100,103020001400040,110200332041001,114004020010203,114002004033124,103204321414213,100012214302010,101100120332004], + 1102011024213220: [100000201020213,114202112324040,103320300114001,102002204004230,101002020340123,101040004010302,100400042201311,112040202314100,114402102310002,112103020203120], + 1003400144000100: [110020001310000,110214024430312,100011014100041,100310201003000,110412121110214,100212341003212,110142300120000,112013212032000,112001040231401,100012104313201], + 1120120020300403: [112131014040114,110000202000043,101012120300424,110322020011332,110304000102141,114323102321122,103100000110030,103014231241000,103100421241010,114214004031103], + 210002220240002: [110400011311001,102110004000221,110040002132020,111144202220301,101434031010012,103101410212231,112402144042221,102144312001130,114400240003203,112000114003411], + 122402310000440: [100200011002200,112001112002104,113134002412222,102100311320110,110430002112002,102240030230010,110030010120002,110242024430440,111003212230033,111020404402004], + 1030201021024302: [112213000200301,100003224334120,110204130004030,110202120003032,100322004314021,102343301100440,102410434000220,110110440020002,101101000330302,102020214010123], + 104114000022004: [114011000014004,102142420210122,101013444003040,101421110303103,100110104300443,102412004000132,101420421140013,103013314020203,100102401010230,101030021031101], + 1201022201410003: [101031020301304,103130314001202,110300000100000,114001102211300,103302320110042,110031422000002,101212402120010,100020321212233,111120022210000,114042324104012], + 1020202040201101: [102430114020003,102011201441000,112230004011202,110212424434423,111200014103002,110214002122002,102400024041204,101000014004024,110030021011003,112220340200012], + 103013122030041: [110000212001040,110020000431012,110034411301222,100132044303043,100012020103142,100402020013040,101014121000220,102120231120442,110021221012222,100441320030420], + 1103021331121223: [104010100010424,103010014013304,102103030201001,100010221031023,100140000024021,101223024200014,112240404012020,101201024203004,112042430240120,104000021220030], + 122101102022110: [110013202003320,101031241000010,102120231343224,110030332100203,114404232310120,103100034001310,114002202210331,100031301020100,110111032140220,100020010200022], + 130001020110310: [100000041223200,102310204112124,110000412010002,110014101300222,111001002110313,111004034402002,102130140204101,103200004022111,103230241200200,111320300041212], + 100000200110004: [102440001113120,110004221040341,103200204031212,100001024240030,100410110002020,114004102201202,101010014001032,100222014121024,100402002200000,102340140222011], + 112121000133434: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 1010200140220031: [100020424300341,101021414001303,103001110120021,103323314024002,101004121002043,114020320040231,110220012121020,100400104302040,100012101020010,103104001422213], + 221040203202140: [103114204002100,114230004110101,102122101023020,100001101033010,102142002000030,114000024101202,102023110221011,100100114302030,100100014302013,102020121130000], + 1011443204402211: [100203321001221,103010041241404,110333010011034,101110140302324,100004141034320,100220200430102,103402000132003,110021200140100,110020011020041,114001000001210], + 143422010004334: [110420140032102,100110014103210,102013130223020,104100302102030,103200030110000,110002002002112,110202120004000,110000242104040,114000444100400,100000200003102], + 122001040441230: [110102224201130,103301201402204,100021020124002,102104131412412,114020312300021,102400204043012,114042014014024,100000000200102,101011011000320,102014040242202], + 121020020021131: [110413304221020,100440000030040,112130010202041,102012404000211,102141010230441,100100341010111,100110214103200,101030320322101,102322121000140,114140002313010], + 131121040414300: [100100100422103,110020134410001,100300020142022,102101002004300,102043001021033,101210211022100,114100202200202,110004100002122,102030301322020,112000020241310], + 210404004012342: [100032024201210,100013401040442,144442110010421,103012134011120,110412412010034,100031030004303,100101132014001,102102024222122,144012013212122,100402230022321], + 100103032212211: [111220212242142,100201010110320,100000221030033,110210402031211,102031004010230,112000012000010,102122014003000,100020330410000,103000411240040,100402002201002], + 1123200003103032: [102300321004202,103003441432012,102311410222022,102000401410111,112000112001400,111101304101024,112240000200001,101021010300000,114111000233241,100001004100121], + 121040040201341: [101001400301113,103101024004200,103300021402104,102102024000001,114003104032034,101012044004042,102020304000321,100021201020001,102110202001101,102144322001200], + 110020221100210: [112142301101040,101100000330120,101214440300301,101121100332142,100000400000241,111102214104403,100132004231230,102011004013000,111200122222334,102301024113440], + 1200000230011320: [100000004100202,101024004002101,110120041200201], + 100300031130042: [100200004301323,110010030440201,110041002130210,110020004414024,114340312301134,100031220121003,114310242320310,114302102300200,111042012220110,100011120100002], + 1423010401400320: [110020301220324,100041000010302,102020100243032,100031001020040,101110404021211,103110041442122,114210400000112,114042014102321,102112222001200,100021104100310], + 130300200222001: [114020000030002,114031000022030,100201211003004,102014002000401,103103241421322,114121012340044,102000400240203,102104304023201,103310300140324,100002224244002], + 122240042001141: [101001210302014,114013414010201,114110002340012,100012001030012,112141220420023,110002204201004,100200304121441,102003241103022,111031014120342,103012400100023], + 100022012023210: [102000024011300,101011210300000,101002221140440,102040021424212,112400020200104,100100001010020,101000000322000,100102021220030,112002022034002,110200140401144], + 100020020220110: [110012000141104,140300020110000,100003301030120,100101004230030,103044004034040,102412140201410,114034000012210,114121200222010,102024110224001,100341231000131], + 200302122220000: [110041210030120,101000100342211,110003022100022,112204330202240,114300014030130,103100140211222,110413310101004,114021140030012,110014240130030,101001121000412], + 1000041201430011: [103114001441122,100422004320024,102420031111001,114211110023303,111000302230100,102300011002030,100120220000101,114044144020400,132202000104100,4000113102314022], + 1001343432440102: [110000212101040,111120002100412,110302012103034,110001110001202,102113100230021,114013022304040,102030100221011,100004001002300,114020100042040,114000304031102], + 1121020021201430: [104110021244203,100200004301323,110010030440201,110041002130210,110020004414024,102103022002001,100031220121003,102102224000012,102100102001032,101100001102230], + 1102020200012030: [110010130000004,100000331040124,102122022000230,101011200324311,112030040242300,112400002021310,111103044400100,103321230110010,100032001033034,100231010114120], + 133012300012120: [103010040142210,110000002101002,100310021003100,441411013130300,113004021002002,110043004203001,112002002000203,100130224234121,102214001100202,110402012111011], + 1003004010201112: [102030004002200,112414102011010,110014012001011,110022410420343,100100410401030,102000040222041,110420200000430,112323332001000,102303044033020,100310000422013], + 1040202420002403: [110441234224400,110030002000422,103100014031411,110000300424304,100032121024110,100011004343022,110013122130200,110401140004202,114020204102020,102402330230011], + 110001033202204: [104103201240410,100300204010001,100011320043322,102204100232030,110110012110224,100200011220231,101004410311320,100200310110000,102002122014040,103112010212244], + 1141212020013412: [114041300010302,114041332330410,102011000233013,100030014212420,110000000021142,102114002001012,100014200200204,114120312310022,122213202201022,114203024110400], + 1020112302021021: [102110120202001,112100042301414,110102030023004,102120314034114,110002101101212,111100320023012,110341222103022,102200120230002,100042024300400,112433004010320], + 122300021301102: [102021024000010,112011012004300,102300010242330,102000401120420,114011102210402,114300100000041,114023204100222,102222014011300,102101430203000,103030204010001], + 1102103131210400: [100002302213022,101030020022301,110120400022300,100041044101100,104032420010121,103412301412120,110122121001403,110012104410012,111013012202014,103200100100122], + 1101420000331020: [110024010440102,100033410104422,110142322000202,114011204102241,100023311224032,100000104310040,102013444011120,101000410303242,102014021131022,100240214101440], + 1104333012010024: [102100230222004,112130000422204,103033000111000,102200404030234,114040120021110,110011002001232,103030044003040,101000114000032,103203400100320,102102000202200], + 1030033234010204: [110120144200000,114022412330004,101200221022044,110241112020204,100002004104004,102100224000210,100014204201000,102103321411004,114113000004012,102140114004004], + 1002012003022201: [100000111021003,103000001004002,1304100402114410,411242003002123], + 1002200204020200: [114201102320021,102104241412020,102010124004041,102011021132412,100010204102110,101012004212201,114000102202022,111303034134331,102222421012100,111101134102300], + 240220000334031: [103122204030142,111002014122111,110200400010001,112013002310110], + 1002020002022000: [101112404231342,110011401011100,103021030102410,110430314220010,103330104030103,102423100202400,100004014300341,114100212211004,102212030201100,100020011230424], + 213213010121420: [101342300314204,114200034110031,114423002314000,114040002210432,100010040122204,103314044033003,114102224104002,102001420220112,114422404110312,101010010300020], + 112011021000022: [100400002201113,102420424042020,100010001032223,102111024000402,114321002320001,102001011100100,114402104142102,102311120222404,100100000422320,102100012002000], + 1010024013400000: [110002021222300,114014104033302,110224030001001,110221120402204,110323110104120,100202324120233,100002300113112,100000001034210,101020104000300,114003402300102], + 1002001034024031: [100202030140400,103010204011233,101024130300401,114424212321001,142011423130201,102000401130243,114031212300003,101022021032142,111001122224141,100011300001203], + 112132134141200: [112110340200041,114000300001030,101220030300302,103233000101300,114020204100412,100013144302033,100002220412021,114120104002413,102111410210032,110031210130310], + 212211122000442: [110001202000032,100024204211200,100010101020403,114230412332011,100001211042341,114032104123010,111322012202310,114330204034200,100010321043134,102302001002104], + 1101214313201332: [110024404211001,110100022010010,102131201401041,100120001040202,102140140210112,100004220412010,101222020304402,101201130302002,111020400044101,411120024124200], + 123300423122202: [100200004301323,110010030440201,110041002130210,110020004414024,101400134043222,114340312301134,100031220121003,114310242320310,101100001102230,114302102300200], + 100000000030421: [102002121101110,112014201121001,102403100202003,110000100041101,103121204001020,100400312200342,112334320201110,101110320330021,102000002043020,110212000003404], + 1040310013112100: [100441204302021,102100101340232,100011320001003,100000221020200,100200000030010,100443211002141,100200010431000,100003421040000,101012400320022,101130031041024], + 1002101034022040: [101021134011012,110332202020000,104120130021200,112421004012141,102011104010201,111100220022101,100021104201130,110030410040101,101300401002320,112001321113132], + 120020400132240: [112113214020100,103300344012201,100122200012014,100000130013400,100011200201400,100001321032243,100201104224131,100002100204114,102211430202033,101031321022412], + 113014042312230: [103203224022224,100143200421104,112200122022200,110213010400012,103240214031201,110210120000141,114022114010220,100010001043004,100011410400320,110102101002040], + 1422302421131020: [102010000231120,114004000023341,100420114302431,101201001010223,102002004000203,100310004100403,101000321004400,102201321300010,100122000402410,103200330100300], + 1421042002004002: [102020041440000,100004004231003,100200024121000,100211011001040,103030020100023,100204001000003,101001030300001,100020040401004,103221001204004,111240404440200], + 1024410000201004: [102100022003140,102102211021113,111400024404023,110020122000043,101004001030002,100010004100021,111240124130104,110012211001003,112003230232000,101003100320023], + 101010121403231: [110002004410202,102103114000024,101101410010023,112041002002124,140343100002103,400200234320200,101041200320322,110200320000000,100001424102041,100100021040230], + 211421030202104: [102021001132040,100032201024101,102301004110004,110402420402001,110000112100402,110021021210300,110404000000012,102000101120123,110221022101104,110023100402320], + 211220400000040: [102332021001000,112110102302022,114101022340004,100200124341000,111203004134421,112120022010120,100020024200222,110101221300331,110211000021000,110002340040020], + 1000031222122102: [100043014203003,112332000411020,112230024010203,100000004244400,110024001211221,102012201441404,100131014234134,112000120241120,100030224300202,112202140201200], + 200132010021041: [101003010300002,100030214211230,101100004004111,100241100430133,110000004202042,110020002124243,100002044201000,100402410022101,114000020012002,110213014242141], + 101111010020100: [110102224201130,103301201402204,102401121113302,100021020124002,111201210000103,102104131412412,114020312300021,101320040302031,102400204043012,114010102300010], + 1002200010232001: [103203020134020,100103331020241,110100121222200,110002001211111,100011440420031,100122031022403,101120030330141,114002212300022,101012134212002,111010400040212], + 100021020010010: [110240040001040,110302014420400,100224000012220,111401002210202], + 111010001021200: [110013312204132], + 1000301410300011: [103044301431001,102010220220022,102301044020300,102111001023200,103211001412040,101004114210003,1004020010032003,110220222123322,100022202042210,100402022200030], + 201041411240204: [100044041022000,110402020001421,110010412101002,101410104020340,100131300422201,100014030414202,114210412314301,114002204023003,110112202140320,100100234234040], + 103010000003331: [110241142024233,101001421031220,112220322030220,110210301200101,111000034110311,110400241240242,102200001002100,114443304123123,102000024010002,102413100201310], + 101024102240012: [111103402241002,111200130011000,102000101120401,101222414013042,102210044003121,110202432243230,101014440310403,100140104230112,111202132210400,100120310112042], + 1001002132441200: [110220040110201,103012004011310,101021024000000,114010022303403,101032344210022,112400010203210,100042010003421,100013114210003,102000124012112,100112114024000], + 1024030410020114: [104132212102200,100041230102210,101320244221142,104100042101431,110424014243001,101410241100300,102000114001011,112004000223004,102320031100120,110231011210112], + 100002210102012: [102123000230200,114200302320443,100401111000221,103302010140122,100010001001122,114000022210140,100000021032200,100100310002103,103224020100300,100400314300312], + 1012103132133120: [101302134233230,100002200103104,101030404212000,102040300241403,100431000032001,100020001042002,100202031002101,102103331400000,100120041020012,101301131002201], + 310142112300200: [100032041021210,110004301222000,102040011121100,114310000001232,111202012222402,111322234130000,102040041320010,103203401400132,110104002010100,102042204000300], + 1131013004232240: [100240000140032,400013004332041,104122202100000,111102010020434,100400204302004,102200210200442,100100021010112,114243204113000,102323210243022,102004010202104], + 1403012324001441: [103110021442200,114023224010002,110020320412002,100104214302300,100300301002020,100010104210010,112203010200014,114101010210010,114012010011101,114400444140020], + 131342102301010: [100440000030040,100023101001004,102001014013004,102101000233302,103210210100210,101043004211000,112340340200112,100001000010010,100002121021340,100002021021432], + 1021104310021004: [110414402020021,114312012300300,101012104210042,101430001010032,112402012020000,103322241400404,103210120100143,101010024213100,110101010011124,100040000123130], + 1103100424021200: [101400004022112,103002221400000,103110020210000,100022141030334,111020142144200,102100201414400,102100404021014,101313201003110,102303001102431,100141334301022], + 100103010031300: [102401021402212,102041020220100,100013100100014,114120204000410,100000001020000,100120234300003,102100014000422,100031011042040,104312001303013,101403014021204], + 1010020204213144: [110010000111020,100430014323000,102011041320000,114240012324120,100022010022031,102014140200013,101240110302200,100031204311023,101232001021020,100012121040101], + 1124002102004120: [110011001021000,102020000201200,110110414402000,110222100011043,101020320323422,102122004000004,114220040212401,101003301110132,101100001100404,101014024010031], + 120010010241003: [120120000003001,110140344200202,120100201223110,103102441241000,100422001011022,122332011034002,100111101000002,111000134112002,114322002322220,111041034404040], + 223030000000000: [100020201020032,103000011400001,103001010101001,110220000113011,111030014120004,101000211031021,102020001021010,111300022201241,110402410002000,110020001210102], + 1010002201000042: [114101024120020,102004011440212,103140320213200,100011204300012,100001021221000,114003134011032,100101234330123,110024000432310,102012101443110,110032220022103], + 223222012000220: [100402210013013,112032040234431,110010232004000,101020004000000,101004310324302,101010030302022,100120040400011,100214044220201,110410002020200,114321224032200], + 124321412030401: [100400002201113,112024212301420,102420424042020,102111024000402,102001011100100,114402104142102,102122412001012,102311120222404,114020404020132,103231241401000], + 1010432304233403: [102114321402233,114310430002402,114222104110000,110242444432002,110021100022013,100244144101141,103000104032321,101023440300102,110140110023004,110033040001210], + 222010140142101: [114024422210000,101040310304013,101023124002002,102121211340110,100002021002100,114403200002401,102111400210040,114204210002002,100044241020200,102000134003010], + 1003341240200114: [110214024430312,100011014100041,100212341003212,112013212032000,112010220224003,100200001001300,100012104313201,110212310000041,100040424310110,111301332200104], + 1122212100020000: [102014001321010,120444400000021,100011120022000,114113014000041,100040014340014,110011202132312,110012421320030,110000211322312,102101404132110,111012020000013], + 1001200302140021: [114304022322302,114202112324040,102002204004230,101040011140142,100400042201311,100131314030200,114402102310002,111100132103413,112142010234322,110323002102120], + 1000121002010000: [111210302220403,100020114202110,114000024012220,114000144100030,103002001420012,101240004230010,103001404013000,100114010410021,101300101002431,102303020241004], + 101211340310023: [114000000032100,110140102142200,100122124300010,100110034101010,110410224241010,111300402201232,111011100022010,100400444100202,102004000201030,112020401130100], + 1010121202021210: [110201201211024,100032201024101,111124004101012,102120004001310,100040341020133,111101344104210,100410220030300,101110020013040,101021204000200,101200111020111], + 1002200002000202: [110410200100200,102113340210000,101010200321421,110413014220021,102132111410302,100203121000000,102200001303033,112110240200131,102213214032230,100421041000210], + 1040000000000013: [110012231320200,101203001010000,141000211410012,100113300012420,103421314002310,101002001110304,102102010232420,100100001004210,103004000100014,102202421120032], + 202001200121011: [102014000220330,110402001004440,100030001042002,111001022111004,111000042230334,112002300240001,114400234121111,101020314000000,110002342000440,102130104000332], + 220012110032030: [110100041200400,111311120014011,100001130001003,103102104000031,110201134243240,110020134410001,111100044100001,102204004042041,101004010323441,102101002004300], + 120021100344031: [111203124100202,110014142204101,102001104014024,100203321004410,100100011220404,102301024113000,110130221222012,102020114003042,100103414042003,100000001020104], + 1010000000402004: [100004204302330,110000100422111,114010314101200,102341014010003,101000030321400,114132202312102,100004400100414,114322134002204,100002320104400,114021310020022], + 140004041020220: [102231130213210,102000402041014,100043324210140,100023024211011,100003201021001,102201100200430,100022010411004,114121300224141,103112011421222,103304001400132], + 101231010040124: [102010114022011,103340041403223,114002200000421,114302210010001,114030004104220,102443211401140,100000221020014,102003224000022,100010031222001,103001114001210], + 1430000201422401: [102110011020012,100312330420301,100421231011102,102200004042430,100003221233221,100103424030310,112032024022220,112002204021024,101010134000300,110032022014300], + 120040011334223: [111302202200100,101120211110232,111031244113111,100111004000020,110041220420220,100104201200030,101020104002000,110101010010430,103242310130011,114414004140203], + 1003400211200012: [100113220020101,114031000022030,100300211000020,114310200002400,103211220100010,101202201021310,103044004010022,114130020222342,100042034202031,112301032022414], + 110200103410113: [114102300004024,112102201102030,103222244003021,102420011111224,100020004300114,100000000413010,110232020002221,110010021200102,102013102002210,101002004012121], + 231320402320100: [100000014102130,100022044344000,140104013031303,101101001020004,110010404413302,110004001104031,100100024003203,100013001214140,110002000040202,110110424221134], + 1003022232202041: [100404030012420,100402022200102,111010302203001,114144212340021,102110001342020,111123420020420,102302104112440,114000142331320,101114414000402,114100102341011], + 230410211231000: [140423043001013,114032402302103,100040004210404,102220421000302,111202000002022,103003004002202,101001200301421,112121110200043,112002002000202,100020324313320], + 1040004400101201: [100003211020020,111000240044102,100330204322010,102111211401000,101030411001300,114022200020112,114201100214222,100000030100014,103000001430211,100014204101020], + 110012002200304: [110400332010004,100023001030212,100000010023013,111121100012001,101020320320424,100014121020424,110313010000400,111002022220000,110021001310041,100030430002024], + 1010440200210121: [110020100042220,114200302320443,100401111000221,103302010140122,102113101400001,100010001001122,104240202023232,114030204021200,114000022210140,100141321000100], + 1130321230230230: [102120214131012,102230200204114,112030210211000,114130312310220,101411010300100,102200434122241,100221114242000,103012204020102,111120114103002,100101210412030], + 1143330433400240: [102321301000010,101002204000401,102210424042300,402104002030100,114200022322110,100102010013101,111100130010100,112001030221202,101120230332423,110040001203001], + 224202020223420: [102101004000411,114221312340014,102434121112224,101200210300413,100311204312442,100001024100241,103000020100131,101211204201231,111130412210000,100011300412123], + 114102200241002: [102114000220010,100431024302303,100020010010020,114202010213010,110231211300200,112004020202021,110003001101020,100221424220000,104134010010001,101110311041004], + 1202110440300220: [102112004000340,100043004202004,102204020232000,102102204030100,100003440411230,101112404000210,103000004042130,102232001100143,102232124031420,103000411411012], + 1011202412040030: [102001140210301,103302220110131], + 1010124300411230: [101012011022300,110110001224003,100401401003240,114100002340040,103000001240214,114132404003001,102102110220141,114142222322042,100030041042011,110003301213002], + 114121122100202: [401210002011000,404010201000410,1014200301032410,1103013112041021,102030001201100,110200024240110,110431004224201,100411031001404,1000000300003014,103000001421223], + 1000340200101044: [100000001220044,102022200220022,102042031102112,102140114001021,102410111110002,100101041040330,102000100210400,114102302311211,112122334022424,102122000212204], + 211104024243303: [110120200030233,100132040031022,110031010430100,100432431000310,100004000014032,102104004002400,110000000132320,111202002201101,110020122102003,110014000442004], + 202202223002221: [103120010103002,102040310222200,100112120404244,102242220202120,102122101340003,110420000002231,111324314134002,101300200311010,101200010301122,102321021000002], + 131330034100002: [111210044131101,102011101131021,114032002303014,101242421020211,111314204120004,100000004212021,110310042021341,100204011000000,111010110042210,100000001224221], + 1101031044011210: [110042220002210,110410200100200,102113340210000,101010200321421,112001402002232,101014421034001,110413014220021,102132111410302,100011104104000,100203121000000], + 1010310030004202: [100220034323210,112121212300101,100001124102222,101200034044300,102204044042410,100020310010001,102220001112023,114302014032021,102404011400100,103031014003010], + 330012000200110: [102010000213110,114400204120131,114213002320124,114100012340011,100402340020201,114111200034000,114133140030300,111003002142001,103011104010114,100400300013102], + 1031000024120120: [110220122044010,110042304412204,114020124021122,100000104343000,100002201003312,110110111010042,102230121120000,103300001402013,100400010013330,102204011110020], + 101000102210001: [102021122110400,113000200131401,122300200130321,130312421011034,122122400100233,103444001210200,102212230201401,101004100314240,103002101220010,110001101024320], + 103101101100000: [114040300043111,110203111111000,114010030024204,102010201012014,102041204000002,102323204112320,100402201004014,100420404320101,102123414032304,112401014040034], + 111011420401020: [110001420424040,101103210334211,100212001002211,101042000300011,100422000432230,102200121120011,110000002010200,100011241032404,100012001234044,100000314311130], + 202000141404340: [102404004041224,102200041120220,103220010101140,101140014001001,114101002200223,1034110304101100,110021041330000,114321140000202,121102001120113,103322000111220], + 1000143000442111: [100020001041004,202421100022041,102100111403011,1000042010002402,1100001420031333,1321202200220200,130030004001124,100040220123030,1132120124402200,1010320200004412], + 224441300400100: [100004001021111,103000004002012,101021004214202,102110030200120,100301421002002,100202140000111,100003000104203,102114320203000,114001112300001,101003104212220], + 1004111021110001: [112413224040101,100220100110400,101200031020230,102403004042342,101024001034211,111122004101222,114001012300002,102121100232012,114000222213021,114102330210021], + 110022042042032: [111102104100334,111210014102030,110401100001104,111440000000202,111200344442041,103141001240021,100001401034130,101220200304110,110403102222001,110420014242010], + 1003022011100200: [110103101201203,101422244020101,102142120224022,100002021021020,102104100233030,101210010304011,100012210001220,111022004124100,104011041220301,100122130410000], + 312010300200231: [102331021100100,110002002002112,110201124221001,100041204331000,100032114314114,114012032240012,110222120103200,101100234021102,101001424014301,110130020003201], + 304030233440431: [110220100000102,102100321320100,114042102330002,102102011414242,100041004100221,100000000412112,110000010033022,102330040242220,102310400240000,101201340300430], + 1022410011031230: [110033000022043,110100200030100,104412212102010,100000411231000,103140021211010,110132020031210,100101004230030,103044004034040,102300231000210,114000200010000], + 100404102004201: [110400112011100,103210220100310,114420304140242,110002012103110,102441030200210,100441001010204,101202240300141,111210002244201,102021111130131,110001022130201], + 1010021442340001: [100200104321000,110000110410110,103220030101023,401300041114001,112032302000220,112003000230001,102004301444000,111133030010200,102103231340304,114000044101422], + 1040003210240300: [141030301403400,120402022102021,110140101300004,114400210002021,103103221421013,102010002000402,101302101002110,100240011000013,114233112330324,110423221000200], + 1121020101201443: [144131233204044,101001131032132,110400010031401,102220211120002,114112002313010,114014010033321,103441112000230,132042400010214,112030200211020,114402010310222], + 110302420302320: [103220011411101,101220111023331,114220014111304,101030301000221,102232034010000,102003111413120,100023101043203,102010311320332,114200122340300,102000031101202], + 210020024003202: [102143124001400,100020440122040,102002034010400,102020030220401,101002121000111,112404002023002,100033134104200,101432024040221,111001404112102,102240101123230], + 1000032214400210: [100202400140300,110421220003142,114404220000142,111210302220403,101100214003002,100004121032030,100404342201400,111240012241220,103002001420012,114440210000102], + 1103202300134422: [114032104100141,110122421241103,112001144002010,101013030304101,102000004000013,102021241324040,102300441002012,102301010220102,102302331100430,103122001440214], + 131000000201004: [101221121202421,111042022141200,101441101010020,100442220030040,112310010200312,100100241020020,100002004342004,103010330100320,101033300332204,100101004300001], + 1000000210014114: [102001444000222,101400134043222,100010400013202,114340312301134,114310242320310,102110021401100,100113201011032,102230000204000,103102044031002,100011421002120], + 1001001302400301: [100201101010411,100202140140110,101100024000410,101220011000320,110240222100001,110140241220420,100240020010213,114213114031104,110002101332340,111003000004111], + 221310330123223: [102001404012100,1010400230221020,102302200210010,102340120222440,114223204100010,111041202200140,111300400002313,111101040014040,100023014313010,114021040010311], + 1022010322231003: [100024234201100,102120201140110,100010234114300,100331200141014,110112204224100,102212234021233,110224102230230,100120411200320,100100341202102], + 202000204010112: [101102400330110,110132011000040,114440140000234,114100220033300,103021020110143,112030001120440,112000014021000,100021100420321,101024014004200,112200030204103], + 102120000010224: [100032041021210,110004301222000,102040011121100,114310000001232,111322234130000,102040041320010,103203401400132,110104002010100,102042204000300,114142044120310], + 1144022001011301: [110320202023400,111431110000042,100302141003012,102004441124110,103303201400021,114101420030202,114421242204443,100000301221024,101224322120022,110104422010121], + 303004040210410: [114022412330004,100103104302044,101041030320401,102141212000200,101203121020430,103130021444021,102100104002224,102100224000210,102020004000014,102100200210002], + 1413003032402021: [102124121023231,114442104144001,101301231001140,110102030120012,102220214044113,110001141011223,101013224010003,114402240003200,114042004100020,111132244101222], + 1000000020000321: [110001114423041,102302014024114,102000031130401,114230100212043,102004200212202,100002134211200,101003324000340,100000014211010,103000001400122,111140220032112], + 103141003023020: [110033000022043,101230004040022,114244120001041,101021020324310,100020140121034,102340211000200,110010220000210,114021000044211,111241224101013,101312014223102], + 1040333430241330: [110114001202122,111021202200011,100001010100220,100414031001210,102000004012011,114023102303000,110101100012002,114421002320003,110001002004240,100030220002102], + 130020004041130: [101302134233230,101030404212000,114102224000201,100431000032001,100020001042002,100013011020311,102103331400000,100120041020012,102012204000242,114143024003322], + 1000301011010010: [102100321320100,102102011414242,100041004100221,100034004211240,100000000412112,110000010033022,102330040242220,102140121410131,102310400240000,101201340300430], + 1421020020110110: [100222204332402,110002040000012,103110100212104,100430101010214,103400331213100,100003001020004,110110120402401,101000234004011,103201440100200,114101000210300], + 220123000040002: [100310120141002,102324014112020,100002011042020,100301421002002,103022021431010,103200020111014,100010004313001,102010200221000,103104200210410,100002200410030], + 103011020104000: [114104220000003,112010212000010,111130222212000,102100112004011,100040204312404,110121102013020,100204410001023,102323000221120,101400421100024,101023100314020], + 1412220020142244: [101000004210011,111230342220010,114010024011000,111122022240223,100004111024200,112404232010231,103302100140200,121103000144034,110420412024420,100000111020203], + 1101102120240300: [101200100304010,100102000022402,100000001033001,101202404042303,100121231021002,102020200220310,100124100031200,101010200321022,103304014010000,112402002010210], + 1413400010130000: [100004001021111,100142010410011,102110020202330,100001010014420,100003000104203,102041410242244,102101220214011,114001214100103,102323201000412,102311110240101], + 200100230314033: [110200304432400,111222404100330,111002234114103,114221002303200,100434000030230,114014032333420,110031330120101,101022020311140,111010112203101,112440014042100], + 101201012403040: [102001200221011,101000004010012,103024000103302,102244221114031,114201024112001,100000421024110,100104000101010,103204400100042,102033401100232,114221002324001], + 1100140000140200: [103104001440422,112030101110231,100110104102000,102000201130010,103202404032404,103331140112102,111014024112203,100100100024000,104200211304000,101202240301440], + 221000211010021: [102442211414022,110122001010214,102101204000010,111231012220013,110022300420031,114230230000123,100101220101011,110000141123103,100222024320003,114013012300240], + 1030231200210220: [110130314400100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,101002024000400,102202031002304], + 131010200010043: [103300120141130,102110004000221,111144202220301,114224204100310,102304011004310,102100144001112,102000041441002,111230424101321,112001004004000,100201440000313], + 1122220302242010: [110001041213031,102300324010203,110414300030001,102100142002204,100030020011022,102040011121100,111202012222402,102040041320010,102402104022000,110104002010100], + 102131000203000: [112030401110101,110321404420200,102201001001102,100211024341103,110210001100311,100022300401014,102311204112020,100101200401431,100120004000011,114002314102310], + 1124003200330211: [110042220002210,110410200100200,102113340210000,110011401011100,102221200204022,103021030102410,110430314220010,101010200321421,114100212211004,112001402002232], + 302130020101312: [103342200140233,114020140103010,1000401022322000,1303010022004241,400100100020140,101020124100111,1303021014213202,400000133010010,1322100311311120], + 122001311320200: [102322014113341,101022104001221,100040201012040,110021422000000,101120030330110,112021004003303,110331012224112,114100222310230,101002200301130,100011120000004], + 1042234310003411: [101002400320042,102212001110412,110334004430003,102300401004001,103142111420111,111041224111040,103000401220324,110401404221420,101023000300100,110222212022003], + 1004201102100201: [100032041021210,110004301222000,102040011121100,114310000001232,111322234130000,102040041320010,110104002010100,102042204000300,114142044120310,101030004010034], + 122040002201230: [110204032030400,100422201002310,100021020021013,110010200004233,102203031112000,112204004001232,102034031324100,102401004042103,102402234023100,114000024100000], + 1004003201032131: [112413224040101,100220100110400,101200031020230,102403004042342,101024001034211,111122004101222,114020040013100,114001012300002,102121100232012,114000222213021], + 133300422121024: [101434031010012,101002304210122,103101410212231,112402144042221,102144312001130,114400240003203,103000320120003,102022002000202,102122020230423,102141002000022], + 101204101000414: [101142124022010,111200012220040,114202002320113,102430001401230,100402120031033,100010024202200,102221230200001,112403004010231,102102021143222,100040320102201], + 142110442142000: [101220040300414,102121211343322,101003140301001,102410001111322,403111002011011,113210210400400,400100441040022,110011022100114,103100001242220,1001221320011301], + 100222344000410: [110120144200000,114022412330004,101200221022044,110241112020204,100002004104004,102100224000210,102310140240012,100014204201000,102103321411004,100400001001300], + 140131143013020: [100000430122100,101200100304010,100102000022402,100000001033001,101202404042303,100121231021002,102020200220310,100124100031200,101010200321022,102000231122032], + 120210011100301: [110021100023210,103122000100403,102023120241131,114103412201420,110014300041302,110020041310021,114241000002004,110020110400102,110321001330010,100000300100000], + 200200002022311: [110010302000004,100102001013034,100001014100021,102030414003000,101342020314000,102112104004041,100022244300030,102422101111002,110132232013130,100400002200402], + 1403211101104010: [100232121210011,101310004223223,112022200234200,110043132100300,114122110032021,112230000412212,103112001211043,102220120203200,100002004201122,110303122100010], + 132002001000131: [110144240011020,110300204431104,411200142040000,101040211000300,110413401240204,112000244001222,114441114123013,114000012334102,101000014012442,102120402001131], + 1010000411200122: [101224001202324,111211144101202,110240102232020,110000300140010,103102134001111,100003114100011,100002314204210,114000114102224,100440030020002,102404104020130], + 1000010033204101: [110110011340130,100210304330211,111121210031101,112312022021021,101041010324010,102104210214401,100011230101432,100032024240322,103202224024200,102130031410200], + 1141404302330020: [100020330100100,1002443410030003,100011231042030,102100141413100,102110021342213,112002310211210,100010031020102,100020034100101,102332100243030,110004424200024], + 300240001020003: [102143124001400,101204400304011,100020440122040,114103212312012,102002034010400,102020030220401,114231212342200,114002122210242,112010244000200,100000020100301], + 1000003440011220: [102210100313100,100004420014012,102240210240022,100102001040033,112032020220030,102024124011010,102000324013042,100030124212213,114210102320112,114234004112000], + 1400103020400220: [102123242001200,102100410211031,100000311022110,100202004324201,102041020200401,100002021042340,111103214101012,104103012102410,101000011034104,101002300312222], + 130002101210240: [100022102100243,100013230100000,1030200104020421,100121120102303,114100222340120,132011000122003,110230010002303,101212413013223,100004424041022], + 1000000241012003: [102422114040010,101204400304011,100020440122040,114032424122040,102020004001311,100301020420101,114103212312012,102002202000000,100022024100041,102020030220401], + 101020101204110: [110010000111020,102011041320000,114240012324120,100022010022031,102014140200013,101240110302200,100031204311023,101232001021020,100012121040101,101022011003022], + 122300000003321: [100011231042030,102111144001232,114200214002024,100111221011100,114112000000100,114033210041030,101003201111000,110000011211220,101031420340300,111121200013000], + 1100012030001001: [100030010011002,101021301022041,100402300013130,140320413003120,101201220402420,400040001020004,1001120000022000], + 1040020300303100: [114423002313120,102300041004010,103000140101310,102310204023400,114401010001000,110402112220024,114002310021310,100021401020000,100203310430032,110103011141230], + 332003030020400: [110010102132011,101000404011142,110020022000020,100002024310012,103014214004003,101014200304201,103101130123011,100030000410200,112410104040230,100400130013002], + 1002000111200004: [100404224300012,110003200132101,110202120003032,102022010220223,102343301100440,110110440020002,101101000330302,101020310320131,110004110002011,102020214010123], + 100202203224133: [102240221000001,114000024101102,100020124204330,103002121432200,102141101410101,112202412030001,100010000101004,112410140230303,114210142321120,403221301412211], + 300101142200010: [100021314202402,103142211442311,100004411033203,111123212212000,112240042042022,101204004040140,100014001030021,112003020230203,114224012340002,114231324103240], + 140102131020030: [110212022124220,100003100410042,100222034340301,101440044041401,111210012243010,102130124000000,100032310000111,102010421413322,102114020210302,100001100100040], + 1030102002040222: [103204214002340,111101222101212,101214134040140,111002304411031,112404322020241,102001310224010,114000224102000,100112034103110,100203200030344,102004004003200], + 1144403303200131: [101342300314204,102010244010000,114200034110031,114423002314000,114040002210432,114010134021022,100010040122204,103314044033003,100040240003341,114102224104002], + 200102200203010: [104100111240003,110001004204310,100001200100310,100010311020030,100200120030203,112022131130201,112332101100224,110101214400030,114020020040301,101011024001101], + 110000204002422: [114112432204002,110412001240302,100110004103103,103004201421221,103230304022210,102023120204401,100012204310100,100104114230000,403140033110000,111020104112201], + 1000240341021001: [112133322013122,102100414000214,102120411343120,103022140121213,110311332020021,102013130202310,100001014201140,100024401043241,102020424001010,411112330100013], + 243401300001023: [111303420012131,110141221322023,101422004042000,101243404044201,110102010022243,122000100001414,112012102004004,102132400224100,100000020204240,100220201202320], + 1401103231022000: [100011021041112,100110034300000,103030331404010,102211114110021,110004021214200,112100142012001,101032324220030,111020102202303,102110010202300,102202004042130], + 130141000102001: [102010004001300,102120404134413,101100200330040,100100221040404,114440012312003,110110121300321,101202010310030,103321311400002,100000040411123,110242221300213], + 1032200100022113: [100300031003200,102310031100100,114002034102120,101020200302021,114020402303041,103020031420410,100002021020001,102322014112302,102000110224002,110021200043220], + 101220401010022: [102132020200100,112000201123012,103312024011004,114410212320200,101211204013302,112020011110100,102030000221301,114023030012204,110014004411404,103020011430001], + 140400220201100: [100000410103200,100001240410410,101042201000011,102030001412241,101001204010220,100004301023143,114223200221140,101012400304201,100031044300340,112004021121002], + 100130210213220: [100420021010013,112101302302202,102212011120200,102344111104233,100432104320110,114021014020000,102121321340000,114200214002024,100111221011100,100023104101340], + 1001042141224122: [110144240011020,110300204431104,411200142040000,101040211000300,110413401240204,100222100030130,102120402001131,100312401002102,103110001420121,110102112010100], + 111031220212210: [131000001020102,110412310030001,114012022302022,101042024210020,111030340040341,110002000020324,110441410001222,100020214110032,103021004043024,112240204012423], + 210002020103111: [102022404012203,110210334214024,112020010222102,100100324232004,102141240210423,101410014024001,114100000212230,102100031320041,112141102011002,110020234201010], + 100230004043034: [102124231401212,114202024111304,110200102020212,114112000000100,114121144001400,102243044041110,100030330104020,103002104001100,101124000303110,102022400222030], + 1430321101402002: [114120220214130,100002200001011], + 221021201104200: [101002204212400,102112300201410,100100121043010,102100240231342,101123110330200,100323120143000,110432111241204,114200200002223,112123142010120,101002321032002], + 114402013010200: [112202411101400,100101131200000,100022204104123,1002411322210040,100300114100322,1020102233442023,401040043300200,100400200020001,101044014000144], + 1424411030320212: [110400000002213,102011121102202], + 1002210300010030: [101030001001022,110230231300100,100300121000420,100402431014100,100100001220400,110330200400021,102100020210143,102220324011110,101423100300002,103111300102020], + 1012104102300222: [110203120112002,110000002100100,102221410200012,110213401202110,102300104113403,102213224110010,102300004112300,102420024020120,100040020001022,102141140210200], + 1120240010220301: [110430430003002,104412212102010,114102024123030,110013112004021,100432200033101,101021404000220,103120140210020,114420230000240,110414012023214,100400100010101], + 1431211001002011: [110320202023400,111431110000042,100302141003012,102004441124110,103303201400021,114101420030202,114421242204443,100000301221024,101224322120022,110104422010121], + 1042204010041200: [111220202240410,102200020211042,100000034312214,110114002004014,134402411001001,101224110303300,100000144311102,110100200402003,100000104100100,101423034020001], + 113320010103212: [110002004410202,102103114000024,101101410010023,112041002002124,140343100002103,400200234320200,101041200320322,100020124204330,110200320000000,100001424102041], + 1002204013000001: [101220224012410,103200041200112,1021000041101002,100111420112041,112001100222202,110332221302120,114102222310100,111300014122203], + 103020121110140: [110104112010103,111102004100101,100122004300410,102202414041044,102140014001101,102000104012232,102021100220101,100230120001003,112042110220004,112203221102231], + 1010013130002112: [110102114204323,111120002100412,100100201043042,110302012103034,110001110001202,110130201011011,101000304212200,102113100230021,100100021013214,110010411223203], + 1141120033111132: [114020100042014,114102010223100,103101000211411,100401100022100,114000002334110,102002104004011,102430144043230,114102004141000,103100130102014,102020024003420], + 1032140004001443: [114100204101002,101101230010000,114100020033022,103112021441120,110401101144000,103124201212022,100002001020202,100422100432000,100021001230011,100114004032103], + 114010010112200: [110141010001110,104122011242020,110213401202210,111103310001234,100110441001000,102312000240002,102012104010301,114123014001020,100004004303030,102001424000000], + 130203020110400: [111021202200011,114110004102301,114023102303000,114421002320003,110200132020200,110001002004240,111010024401332,114010000023421,102202201121140,100010301032022], + 1000024110043020: [102100422004010,100032421040120,101012400343401,100024004210111,102002100222202,100031404302400,114021004100002,111214034100220,102200001122202,100123310031000], + 110112000000012: [101012131000024,102120221022200,114221104114000,100001111032112,114000030020101,112400004020421,112044414003133], + 1240212040010011: [101003214011024,100104400001144,101000301142210,102000244001201,110021424412111,110202002241213,111000200004113,110000012201023,110000011200124,112200210200110], + 121122221223020: [111121100010021,110310034424102,114400202314210,102101211410144,100024201030210,102010111102410,101000110322242,110100001014311,102404110230202,110043400012000], + 1143010112122302: [144131233204044,101001131032132,110400010031401,102220211120002,114112002313010,114014010033321,103441112000230,132042400010214,112030200211020,114402010310222], + 100413240304044: [102102031403230,100041140201301,103021004022022,101001100320224,114000202300004,102114240210220,100100210411410,102100320220140,114011444012010,114104314124011], + 243210203224002: [104111102100000,101021004000000,110000102100212,110130042014110,114423100002212,100011401040040,111121012212042,100001020002400,110012102130100,111000230041031], + 1114340034140000: [101321001000010,101010424210144,102140114001021,100040400100203,102000100210400,100130014300042,114102302311211,114034400040402,102122000212204,100422021002002], + 101302240330010: [101230114202200,100400000020230,100002200103104,114300124030100,100431000032001,100202031002101,102021024004322,100121114230123,102102334000400,114323400212122], + 104201210200400: [102210100313100,114113014000010,101200210302201,102240210240022,114202400003330,111201222220201,114330004003002,100102001040033,112032020220030,102320120240012], + 1011034000324101: [111101010010203,103120101441202,110011000022102,100004104210221,102202410240103,400014404414011,100112004101222,100000010101402,102010414013103,100030001041404], + 1030314030020122: [114032104100141,101213114040141,102210101002412,111140100011101,103220120212134,112001144002010,111103314101000,100012011022000,114140104122430,102021241324040], + 1100103021400240: [100100040423201,102011104010312], + 240000210340240: [114020000030002,100201211003004,102014002000401,103103241421322,114121012340044,102000400240203,102104304023201,103310300140324,100002224244002,114310200002400], + 1012100024010200: [112410104010101], + 1100421022313003: [114033120034402,100023221022210,100012204340000,102104010311220,101000404012321,102230022023230,100401214103222,101122001110433,100014200003002,102201041303000], + 222000240210402: [102001444000222,100004204302330,101400134043222,114340312301134,114310242320310,102110021401100,100113201011032,102230000204000,103102044031002,100011421002120], + 101031112401430: [134032420422100,1002131101112211,220200021120010,1020423021001303,100021204230002,410204010302000,320143400144303,1023121121030343], + 1001130023401004: [100104341010424,103221204032410,100004004102410,101104001101000,103142210104020,114400240003003,112203001103411,100212024121000,101224020301202,102202014042012], + 1001003021421040: [111222000001201,110020111332411,110103001241002,103002431420121,111003230041302,100100220114002,100312004100100,101002004000031,114420010000222,110111022044102], + 241200402322112: [110012220442042,100001114303001,100034204311021,101121024024120,103332211400441,103011131430040,112201104011200,110320204424100,114200112330011,100201244122014], + 1201012101002030: [110020010134221,100004020411020,100300321000010,100000421021322,112331012023100,100021010100320,101001030303000,110031210000110,100431024301030,101222321204303], + 321023330430101: [110424002022221,102000140200220,114233210000201,102104231340013,114102220033034,102012001130103,101120000011032,110202000403003,103303041402240,100000121021112], + 300041433021224: [102023120241131,104103101240204,110020110400102,102331024110432,112002311122120,114000104112212,110012112103040,114420000000221,100104204100000,102341204014020], + 130142121223142: [101211210302210,110040004411013,114001242301120,103000100120010,102001024014230,102011000241111,103201011400200,101234000040020,100001421002030,110024100030132], + 113204200200002: [100024000110221,101301014221122,102102204022310,114130014001202,110010220103020,111004100022110,114040210022000,111001344400222,101021204010011,103012101410102], + 224340300120224: [102242100200221,102300004024130,100122301022031,110401002222004,100120044232001,110021000110000,111111224130002,110414011000004,101010101140110,100100311200002], + 110020002212200: [101211201202134,103120104030100,102020030220200,110100440400010,110003434410403,111110000014401,100000004130010,101300204230000,114002004100140,112014000233340], + 1120010422020402: [110400011243102,114100120223101,100003214102204,101410044041001,110413131000201,112002221131220,112012002302100,102422214021111,114203002330010,100201120000000], + 222322430033202: [102310324112030,100410130030232,103220101421001,121110020100002,100002104204000,140004230143221,144200400000000,103321202010002,101124344200400,102021220202100], + 1022200110100221: [114002202300220,100410300030201,100002024214031,100100324230101,101302314220212,100002044201211,1000122140130010,101020030332421,100004140204041,100010001000001], + 302042000000001: [110002004410202,102103114000024,101101410010023,112041002002124,140343100002103,400200234320200,101041200320322,100020124204330,110200320000000,100001424102041], + 101230131000240: [101032000323012,101402114042420,104301222102024,102003104011100,110444300101200,102034411440000,102302031100432,110011024414011,100011104344414,101220200040100], + 121000402021000: [100200101000000,103110431441100,102101324130010,100011004340114,100011200121231,111201102224324,100102004100201,114040020021023,111230114102201,114201102342110], + 1431112224210022: [110013202003320,110111032140220,100020010200022,100023101042010,102112310210202,101212402120014,102330010243440,111211010002130,111011002200232,114042044100403], + 104034013100020: [110001420424040,101103210334211,100212001002211,100422000432230,102200121120011,110000002010200,100011241032404,100012001234044,100000314311130,101424344022211], + 1020312100240211: [110320401234434,102122011120240,111400204422011,111000304440121,101000101030201,103020000100001,102134441120002,101020101030224,111023214110122,100002121031042], + 222221000013204: [101120204002140,100000020421013,101020024002022,110120011002420,100100224230014,112002112002220,110012404411012,100012304300004,102340411101202,101011421140423], + 1101200120224324: [102104321001201,100300230420220,102422101111002,110132232013130,114121444120100,100000411231103,133101010002020,101401211100001,101131304022211,100240121420111], + 1014311022312002: [112312122020210,110332000010101,110022331320122,110000030132210,114002004103231,101403030300132,102321021102143,101010011001214,102010020213042,114200004000003], + 1001100121011010: [110001012101334,100011101222101,112020114004303,100001114302424,101222134011002,110021324200010,112113012300242,110343232021004,114131044002441,110040142002100], + 110314420420222: [102002130222022,114024044012100,101410300301303,112202121103032,110200024242141,103024104043404,100244100430040,111111104423410,100404411000022,111001020042314], + 1011240012002220: [102044314000340,100000210100004,122333101001221,103203211411200,110320010100000,110003000143033,110300402020002,111031042202201,103001120004001,113400140100200], + 231100200000223: [103111001422000,102203004042010,111244302220204,100042100102211,101114000332010,112112211102024,114001032300011,100142044103021,114004014011110,102410004024030], + 1132322110031300: [130043000011201,130003114014002,102000102421102,103020211101132,102140120103011,101000000001210], + 112122140012021: [112413224040101,100220100110400,101200031020230,102403004042342,101024001034211,111122004101222,114001012300002,102121100232012,114102330210021,100000020401302], + 240201203012311: [104100012102004,102102011413000,100402431012022,102031024013013,110044020020202,102122410220401,110021232000021,110301322104142,100001140000010,110201434430102], + 244202023222030: [100420021010013,112101302302202,102212011120200,102344111104233,100432104320110,114021014020000,102121321340000,114200214002024,114112000000100,114001032301013], + 240144010404100: [114011114123044,103042141430211,101033214211000,114142044000010,101221031020331,102101404000000,102300200221021,114322222322000,114100012204104,102003104000032], + 1443013230001214: [101213000012022,100102031010300,111101304103102,110041002130201,102211124110220,102434040203002,100002441003104,110400020101440,102000310223330,100004304100312], + 101042010101400: [102301000220000,100024114340002,110101231300241,110000140132110,102402010221231,100304100140104,100213444314000,104132100010310,100241000440432,110411200400010], + 1140220200432000: [114100022342130,102102211140013,110210020002243,110121220000022,112400434040004,112020104020001,103002044002032,112344021130002,100101020402424,110122020430011], + 130301014011214: [110020000114010,103000200111020,100113204102011,101020014000210,101002330300234,103121120114230,112014100210000,114012200021133,111000402224222,101041204210112], + 1040241000202041: [112224111100141,100132004231230,110302011332024,110200302024000,110021340020022,101010001000320,110210020104031,101003204000300,110003422000141,100210301002021], + 1020014402020002: [110201201211024,111124004101012,100422314300200,114103220220104,102120004001310,101021204000200,112141104020201,101200111020111,110001200422320,111122222240232], + 302102402320024: [112001112002104,113134002412222,102100311320110,101000041142321,110430002112002,102240030230010,110242024430440,111003212230033,101112331110410,111210000000110], + 112302010204202: [100004124101032,111220012220011,114020034010120,100110224334101,111100214100000,102000211103003,111100110010000,110000400003000,102213000202400,110002031210002], + 1030010300231000: [100000200202012,114404010003320,112114324040000,100141011011032,100010021034000,103132004002020,100000241000002,100000401002031,102001204001021,114300104032040], + 1010411001042304: [110011121230332,110000000441321,104120412100032,102201000240304,101042000320420,102010021101132,102102014001104,100222401210112,110010011210002,111101210030022], + 1200124100113300: [100200101000000,103110431441100,102101324130010,100011004340114,100011200121231,111201102224324,100102004100201,114040020021023,111230114102201,114201102342110], + 133440111042412: [100003030003020,110410000104042,100000040413000,100001034310012,102030414003000,101342020314000,121310232003222,110011300143002,100220021000033,102112104004041], + 1410133102241100: [102142012001000,101100120330110,102300120220103,114141302341111,112023210242031,102042301121010,110003204210204,100022120412101,101002014013300,102100030222104], + 121232241110210: [102020014002221,112031204004111,111201110000033,102130311120003], + 1003321100030102: [102120012001031,100400004303004,110002022030224,110430320104000,110020221320103,110121111202231,100000104342200,110012001214430,110004431040201,113204011001300], + 111012002140201: [110210221300113,110304014433122,100002330412031,114020042302142,113420011011140,100031010010121,102012021100024,111141012240014,102203044043244,111011424110303], + 121100300123204: [114200212322001,100401210020002,100010111022102,100220300410430,101024201114010,102412220200003,110012222000144,100201214123301,114302122323101,110431022023040], + 122010000000110: [114202012340131,110322034430002,102323131001211,112023102003010,101010104011313,102130040230200,102000002041020,100320021000000,102034100223241,102020014021021], + 102100202403201: [112002110220340,114040210021100,102002220221002,114100234004010,100030410102000,112240334012440,102101010210022,110020200001031,100034021034000,100022344101140], + 103043300000220: [112130302013041,100120404230120,112400002023000,101002020300041,102032011100011,102102010214403,101200401023040,114000000004100,100000004344102,112232012030204], + 1040304110100010: [112142301101040,101100000330120,101214440300301,101121100332142,100000400000241,111102214104403,100132004231230,111200122222334,102301024113440,100033230420102], + 120302010314303: [114400214140002,114020014110120,102142030224211,101000034000220,114024022241001,114102140221100,111342314121314,110000121300012,102112411342231,101033100302011], + 1012100000040144: [104121412100011,100404141014102,101211011001002,103042024000034,100042024100140,110210012030400,102011200213421,100001001020031,101000200340030,100001300102213], + 1240201430003220: [110441234224400,114021412213020,110030002000422,103100014031411,110000300424304,100032121024110,110013122130200,111403100030130,114020204102020,103121221400012], + 1424001222003120: [111030212113431,102001111011201,110044320441241,102233034000002,110410122010102,101122404022022,110311110410340,112101202012010,114240004000000,102300104110220], + 1124011212044223: [102100041341201,110112301300041,111041004112110,110230002230040,103201320100230,103021101220320,120000211034230,100010301002132,110100220011244,111242022222024], + 1423010404140300: [103100044030033,102103410200411,100031401222220,100041440102144,101044020301020,101210001032303,100001101033020,101024410341204,110000314214002,110000440122004], + 1010304002210442: [110101210013000,100404121014002,101240220300022,110120020002304,100011000202214,100000024100000,110212214400114,110012101102100,102102304001200,100010040001210], + 100140210044040: [102211230244321,112121214040022,100004004100120,100041014210020,114204120210000,114110030002020,100000030100102,101012400320002,112002100233204,103303001400240], + 1020010002221130: [100003034314200,103300040140032,102104211001200,103300001404011,100240401003203,102000004000204,101403240303041,100002101231220,102040424014311,114240044002001], + 1434420100140024: [101002011001110,114230014000002,110043034212101,114442140003011,101200034044124,102110040230322,100213100410301,100221210412004,101434041013000,112030101121104], + 1243201040030024: [114004024102031,112112210420223,100200340434210,100403010022023,112424034013320,114420212200003,100103401200000,100121201220101,114023322303100], + 113040300032214: [111004302114011,113000200131401,100010410101220,130000311440400,101201440002012,102040031411210,102014004000221,133001230020010,114200140212014,133000000000110], + 1121223001014030: [114032234033303,102320000221020,110102022000200,112431104040041,103123200222442,101403334040004,100003120410040,101040334212110,100131000400012,110100122143001], + 1010020013402110: [102010202004402,111130312211003,103224041400220,110022201100020,102104244000010,100141214304000,101430001012430,100011204100020,101001010300404,103340004020422], + 1020120022311000: [100100204330310,110112214200023,101004204212040,103104404000040,100444021001102,100122110401300,102131341023330,102141220232030,114041114012140,111201200004040], + 1020031102111103: [100422314300200,102141410230020,101134224001001,110020001224021,111122222240232,103300234023033,102340004011311,111134002210042,100013014300034,104132120011021], + 132010000033010: [102420300202421,102431104021200,102002001130001,102404000230201,114100004121100,114002004114040,112134220420402,102142100210120,101023221003021,100000311024240], + 102100013041141: [100002100100210,102420424042020,100010001032223,103020031403100,102200401111200,102000430221040,114003104031111,100100000422320,100102020411200,102100012002000], + 103012110001011: [112112402304310,114430104142400,100011040420210,100220121003120,102212021120100,114021034021244,101041200344232,100002000120011,110003042002123,101104004000220], + 130331000240020: [101400100302311,102141000230040,110030024202101,110100224200101,101122201021010,114000102300220,111011022203010,103021424001214,101230000301220,100132444234001], + 113330320102211: [103412204020401,100014410420202,102100111411342,103223201411202,100202220031040,101013100320400,111110002240312,100413000020041,111102300012024,114023204100010], + 1001000031112000: [110000101304203,110010022003021,101121021020012,110033002000020,101200200300020,100420010030240,100000410000211,100002204201200,101000000322141,100011020000203], + 1011004040001111: [110230000000002,110220301202400,100004414101224,101003140322000,110401001002400,103012000100400,114201142324042,100401424300314,102213401111223,100040120000031], + 101030002100201: [102023104002000,110230010000000,111114010020011,100011014101313,102011114000320,100001204302200,100310111001140,102100101140030,103120334003000,100000004204201], + 302200400401202: [100400002201113,102420424042020,102111024000402,102001011100100,100100000422320,102100012002000,114221030000011,101320224220103,114400202310013,101302131002410], + 1021004130422012: [100012134302230,102012110232021,103300201400340,102002230200001,102404341113402,100020000100311,101444031100130,114404214140114,114400032310444,100120031042012], + 204301012201031: [110004110141201,110413004244000,103200124032221,101220141010040,101020024000200,112210210200000,114112022340200,112033012312000,111230202223302,112102022012400], + 1204212142000240: [110040102001121,110200321303322,100010030100011,114032024012040,102012124012120,103002041402004,102103030210003,114120034123300,103010011401200,103013224034023], + 1112000000230043: [103042000102130,114024042300042,102101100314230], + 132010120104300: [100240000140032,110001202003004,400013004332041,100400204302004,102114101444001,100022121031020,102141010230201,100020210101002,100042420003120,102300220220432], + 1002441120400010: [102321104111003,112441402014033,112100022300110,101123210321002,101003010340102,100022024212302,114104002204400,102004221132241,100010000002102,110001010130320], + 100440122002221: [110222020012300,101230004040022,114244120001041,101021020324310,102120111142201,110102322040111,110010220000210,114010304010030,114021000044211,102140001402011], + 1000440230002240: [114014112300100,114030034013101,100000044204004,101013004001421,103000014011004,101020224210014,114202244101041,100122310020400,112423102010012,102112022001414], + 131312020420222: [100020004313034,101400120320033,110430030000041,102140411342420,102020004000301,114114204001401,101042214000121,102000121102220,100014300000200,100210130430132], + 130222024001011: [102300241002244,110001131312220,100003420012212,100002210401034,100011000002042,110003302002201,111033020040220,101013011030413,110010032000411,102031104022213], + 100012030030122: [104100012102004,110030002000422,102102011413000,100402431012022,102403404004110,102031024013013,110044020020202,102122410220401,110021232000021,100001140000010], + 1432102004011421: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 1100402030110040: [101233341022410,100020001041202,103301014031303,110111020032031,111004004112000,111011002200001,104000131220103,100001002213422,102004100220202,100003000004420], + 200040031000002: [100000101040120,101022344002202,114313044003041,102011101320031,102013000200442,114024222212420,102234010200304,101220020300041,102141010210030,102440011400244], + 124400001230204: [103000224004103,103330201404321,101110144024221,102110201342010,100400042200210,111100212111142,110002002100242,101100000331000,110223111304101,102011310220424], + 1021022100204004: [114023002202030,100032024201210,144442110010421,132000024420100,130013324120310,100400000024411,124131120303003,103100111422330,111031200120202,120000221031424], + 120111110303321: [102100441341013,101440004042202,114201000004122,102201024041200,100100204101010,101223301020130,103312401404300,111141312211004,100341044310403,114002134022331], + 104313042102040: [103000140141214,102422021113012,101010020320410,114020204101200,102304021004012,112302412022221,101021321034010,100140014100401,103120021441003,110001120421122], + 320200022421000: [102300100242401,102010004001300,111223042243230,101121004002140,101221121020302,110000124410003,100000030022004,101032341110042,101202010310030,110014132000230], + 110400400400420: [103400104001022,100003220413213,110021010021210,100111114030020,114331000001140,112300001132401,112102300201100,110310130104000,110020331031031,111011012201202], + 1010110212130144: [110002022002032,110000242002021,110042130002002,101010000324423,102421340201120,100002204300121,110402332010103,112400242014010,112410000203032,111430002210013], + 1000000431002002: [104132340011314,102203304123030,114012040020310,103132004002242,110000212104130,110200200004002,114131040224332,100123020032031,121002023311103,100021124203441], + 102010021010121: [110332102020012,114103204102140,103122001441103,103141214004200,114001242301120,114002144122110,114000430020024,101104301103200,103100101424001,114222404114003], + 214104000223132: [110102042010220,101020124000413,111210000001101,114013400011030,101020111030400,103004104010210,101220024041000,102010300201414,100202200003011,114330432320002], + 100340204312000: [102040431121110,114111100021420,112024212301420,102212000200124,100300310140241,100240134323001,102111024000402,102042000222002,102001011100100,114402104142102], + 1011221130141212: [100021311233000,110020200420132,103111104030033,104100031240003,102300024110101,111010204111010,111200302222011,100113144300434,100010010004402,102021310220414], + 204440100100000: [110001022102002,101020200320000,100000001210103,112240024014421,100202141010030,102130141120221,110103202122103,100000210112011,102041320202034,100033224204041], + 1402003440004012: [100300110110121,102002322010030,100321101000003,102121041101300], + 1000401044124300: [103002100100101,110000402000040,100240240430022,114022300002101,102323131000021,110300124420043,102101000211104,110122000132404,110021422000440,102201400231110], + 100041004211101: [100010211233410,110302140014102,100412210430000,101320131002020,101441040302130,102000241101101,101012121114000,111000120042010,102220030230000,111001022111004], + 230102321400013: [101121211101004,101114101012020,101001304001101,102002112041034,102041111020030,110022001201023,100000040001141,103101124003110,112401144042000,110002001231100], + 130301024000200: [103120101441202,101002121003112,100030211040004,101201021022111,100014001040120,102122002000222,100032011020003,101441104023001,114100004000000,101102121104010], + 1111410010002020: [100103104302044,102020004000014,100400001001300,102000220220104,102003321120000,114202044111100,102102044001132,100020221030411,114000144010000,100010100201100], + 1412113402123230: [110241142024233,110441140102024,101001421031220,100413311002132,110210301200101,110400241240242,102200001002100,102210101121104,114443304123123,110023102103200], + 120024241020242: [100422040021304,111111000014001,100021320123031,100014041042003,114033400011210,100002010413410,102010221132220,103100204000400,101433010300204,102114321401000], + 102103230130302: [114142204123102,101002001002143,100012000002410,110200234210233,102000024010442,110023122133011,100401400012420,112111304020020,100002110422103,100233334220102], + 1030032004100202: [111104004400200,114002102301424,112222002031003,103141324004100,100020004200210,114121104000220,100011004201102,100234120400143,102300010241302,114121012340403], + 1043322302140232: [100002021021021,102200000200300,100023104101340,100000101040020,100110040013320,100000021030412,114023012303230,110021212132303,100003340410121,112442220201020], + 1010140300231000: [104100002100221,104310001300102,102000321102310,101200011020000,112000044002102,114021132202032,102134044134410,111300220000230,114110032343001,100110101040020], + 1420011211022221: [103034031400131,114002114012041,103322000112244,111123412214002,114200220003001,100043121024120,100001011022100,100240110002411,103410000104330,100104104302020], + 120210100002032: [102010124012100,114022212300211,114000002334110,114102004141000,102000111101030,101003011000111,101102204023404,100440100030210,114200340003213,101200000300200], + 111102022114004: [103012034041202,100100204100022,103130031241103,103234031200401,114011320024214,100233001000010,110322311300120,100204431000210,103340404020014,112100204000103], + 123410011231102: [110243201202110,101134001041000,102011031132204,102102010314022,101220404040140,103023101411020,111120010020204,111020144114102,100101001204002,114101200003010], + 1011000000421200: [101134030011000,112000244001222,114441114123013,103220211421421,114000012334102,101000014012442,100301311003043,110112441222211,110040022122412,110430014221230], + 214101120020031: [101012324214020,100000004214210,100120010020214,103411120100301,102110211441000,102100120311400,100103301022000,103000331422023,102020442002001,102021004010203], + 110202022021301: [114010200040441,100000344100100,111304022202211,102302011002003,100012441030002,110222042022111,101022114003000,112011004022010,114024210021201,100013001041311], + 203021043322003: [110101210013000,100404121014002,101240220300022,110120020002304,100011000202214,110212214400114,110012101102100,102102304001200,100010040001210,102002020220000], + 104030031111400: [101022040322021,102042100242012,110201310010120,102100201400021,101113031012041,110030441223002,100420011010004,114413012313200,111234024134400,102011011131431], + 1012002001002010: [114021412213020,110030002000422,103100014031411,110000300424304,100032121024110,100402431012022,111403100030130,103121221400012,102022400211311,110030400004330], + 241242113121020: [100132024030302,121310400440314,120100331332002,111042430000132,101100311144441,132303424001013,123320003100311,111002002142200,110302002000113,110220301300022], + 1001134002000020: [101221004042212,100303111000101,102011101321222,100010001023120,102002101120132,100202000430000,103101041210203,110400040000210,110020401212010,101230420300200], + 1020213030213142: [1020110422203030,112002010100420], + 102444101021303: [102200041120220,100100001041204,100002001024002,114002100040223,114101002200223,102430001400101,103210140100004,110021041330000,114021404100022,111030004402002], + 1120000112021101: [101222101202341,100020220410142,110000412003001,120202201010210,112042024000020,110022100044100,110003000024101,100010024302100,100000011020412,102022400210202], + 1100101241403014: [101112104200011,103032221421243,100120004300002,110302010102310], + 1113302000421110: [101232314010241,100301300121100,110042400130000,103020124010320,100021300101201,110230022122031,101000444214021,112102112301130,101244324043222,112102232300222], + 311012232124143: [102000004002101,110202000000310,100422314300200,101403014020203,102141410230020,100042030120422,101134224001001,110020001224021,102321234111310,112100000200031], + 1423322311404140: [103324024030212,111022412140224,114110004121301,100212034221414,100222100402024,112002220220002,100121301023030,100020224310403,110000130020003,100014000022201], + 1012404420212140: [110000101304203,104121412100011,100404141014102,103042024000034,101401001010021,101200200300020,110210012030400,102011200213421,100000001020100,101113024200231], + 1041344000001000: [110203120112002,110000002100100,102103034004032,111100014404020,102300104113403,100200001000210,103230041400313,111210124134403,102141140210200,100012010410000], + 1240000021202013: [100221424320111,100203104322011,100021101021200,103240321400010,102010134012140,101204211020322,111102002240013,100011411040002,101002114000002,114010000020004], + 121140110041321: [103241104032021,100020114101410,111221222223134,404220140010113,1244000013132404,422002310200202,210111004010010,304130030001002,104112143430303,1200041011320103], + 1012243022422200: [110021310040113,110301331234001,114403020002032,100400110020001,102120104000032,112402234044121,101020121032021,112202240410200,103110201240222,112112220204023], + 101201122213014: [111101034100200,102001140221330,114221122320002,110000100442023,103300101403322,102201111110002,101103021102240,100211001000020,111202102223103,110000100131010], + 1123230221423321: [101010201030113,102401004043011,114012012300010,102223134010120,103020440120000,100302000140001,100241224311010,103000200122014,111302120011012,102013220201100], + 141400200000302: [112011014020221,100112101011130,103000204010112,112310022020213,103430100132341], + 1410200022242110: [103044010120003,110142020400012,100142011022211,114230344103210,100000001021041,101000401032212,101303414220001,103133031440020,100110021040020,102110421342414], + 122014121302022: [102100010233022,102120400212001,114313022302101,114021002302020,102313204114304,112100102300200,103001324000110,100002014200021,102300401001010,103212320212011], + 100140000110010: [102102000213403,102334000243030,100140000410014,101041344000400,100020420123031,102412020234414,102202424111200,102100040220330,101002424214013,100012101022110], + 1002204031202013: [103111001422000,111244302220204,100042100102211,102110030200120,100202140000111,101114000332010,112112211102024,114001032300011,100142044103021,114004014011110], + 210120012302100: [112000012000402,101200020300410,100110224304220,102330211001002,103020134004314,110131211140311,102342202000410,102212141112000,100023020200332,103002004000013], + 110100132220102: [100440031001120,102020200223310,100020001041410,103220011420242,102032012000101,114014112302234,101004201001232,112102102302000,102141231343401,101231104200000], + 1000101200300222: [110420140032102,102013130223020,110002002002112,110202120004000,100041204331000,114012032240012,110222120103200,114000444100400,100000200003102,101001424014301], + 1000004020020200: [111004020011212,111142104402301,111022004112043,100121204030012,102000421444300,103100020121314,110033001204200,103020404010202,114210344100320,111330002203100], + 131103000432010: [100042304102210,112202000411103,112132434020310,101040100302002,100013030100002,103340114022112,100310034310200,101014014000004,114003022300020,114001000010010], + 111200143020101: [110102401201204,102200130202201,102414034040100,100212030414010,100412200002013,102020041321410,102301324112020,111340300010010,100100001010314,100120421044222], + 1110312010121312: [102000034011002,103204000110000,100001014340021,102103001340022,112032000211000,110032020020001,100002110000131,114100102202223,102331221102213,110214012030140], + 103142444003120: [101221311022241,102110001142401,102041100200402,100101200403200,112100404000230,114012020030004,114100124100130,110400112021140,103001304002001,102110020310200], + 120410020211102: [102121240200000,101212040303123,100011221032200,112401042010001,101130314020142,100000040101003,101422210301101,102321001000013,110010102002030,100000104102100], + 202040010121000: [102114000202302,101030201111010,111000004122204,102120411023000,102201110212212,103100001420200,110402031313432,102020214011010,100000121020141,102031104021120], + 221100233014010: [102301410242130,102122020202000,114100424003212,102203402022100,103221104003202,100122321001241,110100304220012,110420004222410,101404301110014,102220012001030], + 120420422412040: [101000004210020,102210314111120,100032300010000,114140404123402,100010300414000,114132302200001,100013004300240,102403234023010,114011414102023,100002220120003], + 124210130240000: [101011411020120,114201232330041,101000010201420,1320010021102402,201200032021040,142321203003111,100040011432042,401000020221031,1440003320032101,100201001100200], + 1412041020034402: [103134014000340,104103100010141,111101222240010,100040210411102,100110004102034,114112020212203,102040140220220,114010400014304,114300132321233,110000140032001], + 313321202002420: [101012034000001,110200220001104,101100404022042,112001112001040,102120004000102,111010112200231,111101304104023], + 100101010340100: [110241024242442,110444010032242,112220001100200,114014130041210,104132420010010,100001041031013,114212102310100,110300112023012,110224200113042,103203404020010], + 212000020100200: [111112002210022,103222004002001,100003421042112,114240004110231,102024021130010,103200224020100,103013024002104,112012010230002], + 122100210103004: [103321411401411,100042010200121,101000010300200,101022220302103,111010200000412,110004442003322,110400141001003,100004300100000,100400110022101,112010000243420], + 122042112211230: [100422000031421,110302040102004,102220021120430,111341300012200,100102000010243,112410034040040,111302304130401,100024334203210,103031410122401,100040021031201], + 1124210402210131: [100244104101010,102032204002001,100200011002201,100211310140340,114004012302010,102340400242003,103101024001202,110433104224034,102041421100240,112200000410000], + 104000031230221: [110000402130200,110210002110430,103024004010134,110102204202001,100141101040123,110422420030000,110004102001020,110040002032114,100120414100102,102404224041131], + 130001012010402: [100443120030100,114400012310301,103032411100001,114330422320020,114104002340200,102034001134041,102100030222020,100030414200111,112210110200200,100032001042221], + 201102100322400: [102141212000200,101203121020430,114144014122041,100022001040322,100000130010033,110020030024004,102324000240024,103020014040000,102312301104422,102220000200014], + 1010200202311132: [114002104014300,102000311102212,102303010241010,102010004040000,102230130203001,102021401324232,112433112020200,101004410311232,101201034010420,111220410010144], + 100240030003133: [101210320301302,102100221340112,100114104101001,114002244103320,101023221000031,101400014040400,102012034000402,114221004002212,102100122002001,101000011021414], + 140003220121202: [102102000213403,100140000410014,101041344000400,100020420123031,102412020234414,102202424111200,101002424214013,100012101022110,100400222200110,114011112202020], + 110010013000044: [102203102002140,100033103342212,134101404212003,104022100000144,104203010031022,101020401301300,230120100011341,103012001430410,103012001410200,103030010103403], + 1021144240004201: [110001010021422,111101302241011,102321321100021,110003020000014,100122121004244,110000012000421,101001104011010,100304201000400,100230111200001,101410020300220], + 1410010302202024: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 104412003123341: [100000001220044,101321001000010,102140114001021,100040400100203,102410111110002,102000100210400,114102302311211,114034400040402,102122000212204,100422021002002], + 1041100200210222: [102320130240202,110140042002031,111001024132202,110010132030102,110012000002021,110223102022103,110120100000300,111013244111024], + 110041103423012: [114313304002310,102004110223232,112204010411101,103202404003021,114010044120122,110040022200130], + 132312142222421: [101133114022040,110210004434230,111100132241003,110100000020000,101134414020201,114101042202201,111424224422011,102301340200323,101000004210142,101340020341021], + 1011211210000220: [110021010040000,112201310202402,102040041132401,114200002320001,100011101000012,101303224221230,114030102300322,114402000003230,103000001404102,102113021343210], + 201221042400021: [110130321300301,102240200242002,101000411030013,102110312004000,103012004020122,100313041004240,101322310313010,100000000410101,114403020000214,101014020310002], + 112020104020410: [110232022123020,100002004303100,110130010102101,100010240101221,111000122201420,102100010213413,101024011034002,102000041101100,100042004301301,100012021031014], + 104102022100000: [100011001021002,110000141012003,110112301300000,101040100004242,100003000100210,110000040041001,104002100004121,102443320233202,102402001113222,101000021032102], + 104120000241311: [110100120400020,114030000030012,114231032340010,100000010202201,100111404302321,100012024210210,112020021120403,101010304211420,101040240320200,111140214103110], + 104201011140420: [114010330030011,103021220104200,101010020320000,112000210211020,100010324210003,101000000343443,110002400011111,100402132200000,111100300024000,103144040104204], + 301100000100031: [102040431121110,100400002201113,114111100021420,112024212301420,100300310140241,100240134323001,102111024000402,114321002320001,102042000222002,102001011100100], + 1110203002103010: [112000302000201,103013140100312,100000424301231,111101404104101,102133114020301,100234124224203,110032224202331,100100030024102,100044010000141,112043200240400], + 104001300221024: [110213100122010,101212101023221,110213001300231,112120222020002,102130100222100,110200204432001,102020411123201,103024041421002,102200034042002,102030004010204], + 1244220041140201: [100021400101221,102241341113010,102300020241001,114100124100413,101001114012114,101141400302200,100002044101122,103342424024214,100100021040420,112002242001002], + 120100402100213: [102203304123030,101000040320021,114002210021300,103230114000201,101401300300011,100021124203441,114121002310010,102042210202230,103141131420000,114014002300100], + 102000023010202: [101011321003202,102000031133000,102101401342211,112300210210310,100122300411032,110044121211040,101403020301000,101023244041002,100001104100201,110120001141121], + 1134022230020400: [110210020002243,112020104020001,103002044002032,112344021130002,100101020402424,110122020430011,102021214002010,112211120202000,114211040011201,114141044004031], + 112110300130010: [110201124221001,100041204331000,100032114314114,114012032240012,110222120103200,101100234021102,110143020121321,110130020003201,112100210200401,101010001002200], + 1401134010200300: [103000004002012,100002011042020,100301421002002,100202140000111,102010200221000,103104200210410,112000002000420,100240101000030,102012401001012,102302211002004], + 1000000020011202: [100010241020042,110301222101042,112000303004042,110113014221020,112003204004010,101202024013411,101100401103020,101432320330300,100430304100000,103440004000121], + 1434102040002221: [110000021202100,100420014301410,100010101020403,110302030011010,114230412332011,100001211042341,100020111001344,101004024210301,114021004020043,102302001002104], + 1102002014001000: [102302340241312,100410410002011,102101224002210,110311232120010,122203322100011,114141142204022,102010010220014,110330022021224,100410311001021,110123442011041], + 1010131121142400: [110130302012020,102000100222110,100000211021004,102411134020204,114032200030021,102000000224012,110210120000001,101000120303020,102000001133312,102202220200320], + 200134100012443: [112324002020202,100322100143040,101401140300101,101242000300000,100030124210101,102303320221102,114203224111020,100140304103400,100020210021010,102012134000123], + 131202401030111: [100421221000240,100210201004400,102100302004202,102000034041230,102110100200220,112012132300102,102301001101100,101020144210420,114100002312000,101122224003222], + 1020200410234034: [103020401400041,101011210314200,101211411020304,102314311100010,110042042002231,100400142200202,102110021342220,101000321141220,101300324222000,100222300001000], + 220021130044301: [101144221103220,100240240103113,102100220311002,110040300120130,101000011033200,111031104402020,101230120301104,112400212013204,100340001000022,100002030422001], + 120101001111203: [110001334214240], + 102100114020110: [114301022320021,103344200113430,114101104102004,103030404010000,112100102012303,303020404011031,102012044013241,110020202100303,110012010122100,100101004232101], + 222200400140031: [100003420100302,110210010000210,101200210302120,100200000431211,110300112103240,110102012000210,101320400314000,100201304121202,112400004020024,101004011110001], + 121333200101010: [102100321320100,102102011414242,100041004100221,100034004211240,100000000412112,110000010033022,102330040242220,102140121410131,102310400240000,101201340300430], + 1030102204103011: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 1101242040310021: [431102031002020,111010234400002,110422420030000,110004102001020,100000340000030,110040002032114,102404224041131,111020022204020,110002310002020,102010222001321], + 323030021340442: [110020402002300,110201012032242,102011001134111,110310100011310,114102034001211,102022020202210,100314111000314,102311011001213,103222004034100,102002101100313], + 211144400200002: [102420044040023,110410202122004,101004204040210,102332331001100,114022014010344,100120404300300,100021104314210,111023304123001,103000001400001,102400021111004], + 1123121021003330: [101220014012231,100104024303320,114422004110130,101010311003410,112210132031001,102010310213001,114021114023402,103422430124013,114242312322020,102021221120401], + 114110030140411: [1302101004142102,1043303323011400,1002000010441103,1122204031101014,140011220320300,114200022340011,1003033202212100,214301004122000,1020002000321320,1140332400310103], + 1003210022241402: [102203101120000,100031200410420,110034022104420,112013001120433,101021000314120,112104000200322,102103200210010,100022101040044,100024000102402,110043301220422], + 1440413001212002: [102304130242220,110234010110023,114020400022001,100020034302021,103001001424322,102002221100222,100124030401241,102101044001201,114123100221401,101411301011220], + 1112421134002320: [112203002024001,114020022210340,110200100112424,111233002220320,114202100000010,110402001004440,102030014013002,111001022111004,102211231100243,100341201000300], + 130421000200001: [110011200022210,1320004203402400,140000221300023,100211120430001,400100441040022,1302200002412211,134100011032002,1023200041003410,100103030400110,1001221320011301], + 120000434000000: [112413224040101,100220100110400,101200031020230,102403004042342,101024001034211,111122004101222,114001012300002,102121100232012,114000222213021,114102330210021], + 102040000020041: [104244002023000,114012412200022,110000110000231,100142041012023,110000000411120,101301030313022,111440222100012,100420111002101,102032130242000,102120001340042], + 1013140022402012: [100121230031032,112000431120410,100122200012014,103042024040104,102304104110001,100104211044110,114241222321321,114021002302020,102313204114304,100013200100011], + 141420312200240: [100021204100204,110211020000002,103002034034022,111230214102412,111433044442220,101000004013020,111022120023311,110041341300041,101013320300001,114102314000101], + 214041010200400: [100301224310100,103002104012101,114021000012031,100012324202240,110003410100312,122000430101030,114000022300301,100311000141022,114000000021100,114210202322020], + 121031103201130: [100021000104004,100002200022012,111140204103210,140004010302423,114200320003120,100200113201000,141220400002200,100044231103400,100411033204412,110000001210210], + 112010400120024: [100000210000202,101043224001442,100021100001301,101001004002100,110300214430000,111022002234444,110002001220310,103204144020011,120202001100101,102101224000230], + 1043200020041140: [110020001310000,100310201003000,110412121110214,110142300120000,112013212032000,112010220224003,112001040231401,100200001001300,100012104313201,100002201032401], + 1030042232041220: [110130110032003,102022120211140,101240404044200,101412040300434,110412041340022,110012241310243,114123302313020,100302010140002,101002034212140,103001000113103], + 130024304042204: [100040401020114,114202400210000,114011012304232,100043111020130,112001201110014,110213300002210,102402200200000,110120200000200,114103040222002,101020124210122], + 230420100204041: [110413340401411,101230031023011,103210200213211,100210110002020,100400040020030,114021140030212,101200101022022,111100132110002,101430334021100,113111420100023], + 101004021201121: [102001204003131,102101041340032,103010110120332,100012020204300,100001104301010,102320110243020,101002020304011,102432314021013,114001400022003,104010000000320], + 1031000200020223: [104204010044121,112014200224221,101003110320100], + 1041100023130321: [114103402201140,101313004232122,100001004301400,102111420210110,102104131414203,102000204001042,101231220300123,101020020340421,114100232202021,100001040123200], + 200103142204220: [102111000202241,103232220103211,103202404031100,102022004010004,100202204222000,101201114044200,110422420000022,101412010300001,110040304210001,101002104042030], + 201332221010311: [112024442000120,100100320100331,100010021042030], + 100000003041333: [103322030141022,111000204110022,100140040411202,114301002300221,112033130224021,103211001413304,101000334001322,101022234003121,114202200012032,100003111002443], + 123102202000000: [110401112220304,101000001110010,102003214004242,102300001002032,101014211003211,112021340220023,102030004000210,102023030221340,100020114102022,111000004400230], + 113031021300300: [102202004042024,110140001010224,100200021000412,110002131200133,110330000400112,100000004300000,110000000130104,110103041012020,110112401320042,111233314101101], + 1020300000000322: [101011000322203,101012130310043,114102344121242,100001410411142,111432404442442,114421102322111,103224324020100,110241022112013,102110010230101,103002341221402], + 1114020234140010: [100030220100110,100002114314022,102000100200100,102020400244030,103112100101020,114402102312001,110001102103432,112033300230131,110102002011031,110032402130011], + 100240320014403: [102100221340112,100003414100400,100114104101001,114002244103320,101023221000031,102012034000402,114221004002212,102100122002001,101000011021414,102102201121020], + 320002212410003: [103102041440324,112110032304211,110042234410000,102424111401024,110020004203230,110010042000123,101100240320232,102110024004002,111000102230321,101322100311212], + 1000242240111412: [102020220224000,100421000012113,110200020000000,112030332302201,103040014004200,101010004000412,101000310322011,103220011413012,110421402223342,102044021103423], + 221043011013422: [101002201021102,110140102142200,100011221020231,100404002200222,102130141411003,112020101110224,102004000201030,100033204201121,101000141004421,112140234024202], + 1022300421000102: [103340041403223,100000221020014,102003224000022,100010031222001,103001114001210,100024311220202,110043222124300,100100420400004,102023001320134,100024104312140], + 1014000302230231: [102040431121110,101221020040220,114111100021420,102212000200124,100300310140241,100103104302044,101041030320401,102141212000200,102042000222002,101203121020430], + 1002424011211100: [103134014000340,101440004041120,100040210411102,101031214000041,100110004102034,114112020212203,114302020003041,102110014030002,114300132321233,110000140032001], + 110004403100124: [110033100114102,114330004030120,102410101111403,102310140211101,110030000021420,110221002022122,111120144101403,100024221230411,110230000002421,100020020003311], + 200210010121103: [100000020001023,111144042240304,102400021401101,102141201342300,114120424122030,101014000322121,100220121001003,110000104414200,100002001020024,100020110412022], + 211001033004401: [102001404012100,1010400230221020,102302200210010,102340120222440,114223204100010,111041202200140,111300400002313,111101040014040,100023014313010,114021040010311], + 304220041042221: [100021004310222,112220322030220,110313312021120,100220214333200,110330234422000,111000034110311,102000024010002,100202000433120,103302020111204,114113020221100], + 1000011301004101: [100021204100204,110211020000002,111230214102412,100113410410320,111201442222420,114012000022010,110041341300041,111022120023311,114222440003300,114110420031102], + 101221403440431: [114302442300121,100403100013110], + 202220440443232: [114042304100001,101211240301300,114203134112000,102000000221441,100130124030404,101401321012030,111402100030002,114040114100221,102300131102042,101021121112112], + 1010200240400200: [110004301222000,110221000111302,103100104000121,110024140142000,102011440201423,100321001001010,110321302022203,100002204310140,110110210011002,110221322123012], + 223203421020012: [100000430122100,101200100304010,100102000022402,100000001033001,101202404042303,100121231021002,102020200220310,100124100031200,101010200321022,102000231122032], + 220200100013402: [100101201003011,103101000121031,102200300234001,110022002200032,114200034113002,102140041411342,114214012341203,101040204010120,101004004031120,101042221020020], + 1110314100003120: [102442211414022,110122001010214,102101204000010,111231012220013,110022300420031,114230230000123,100101220101011,110000141123103,100222024320003,103323001400013], + 1422024000012004: [101042104010000,114000122301411,102111002001230,111102010020434,110410000002004,100414231011020,114243204113000,103130004003141,102323210243022,100400220002400], + 1020000023010431: [110201001212001,110200134240420,110403221000002,101201304200320,112002320212232,100002210413202,103140021401211,114002212210110,100020200104120,100101140102400], + 1101410102402310: [110141010001110,104122011242020,110213401202210,111103310001234,100110441001000,102312000240002,102012104010301,114123014001020,100004004303030,102001424000000], + 1022123103202022: [114024422210000,101040310304013,110300000100000,110000400022241,102121211340110,100002021002100,102200000201020,114403200002401,114204210002002,100044241020200], + 1240204000404100: [101002434000030,110304000102201,101012410340104,110401340400011,101210031020103,110210020000000,110110010001234,102310001001131,111012044400414,114330204030213], + 310100312242222: [100010021002314,103100111424040,103210001410031,103002221400000,102022030241032,100001101030430,103001010101001,110220000113011,111030014120004,111020142144200], + 1010042040432302: [100000001220044,101321001000010,102140114001021,100040400100203,102410111110002,102000100210400,114102302311211,114034400040402,102122000212204,100422021002002], + 1000020041000003: [114002032301210,100232404222422,112000201123012,103312024011004,114330302322210,102311020240221,100023141220100,101211204013302,110014004411404,100010124300001], + 1003210214000341: [103044010120003,100142011022211,101000401032212,103133031440020,100110021040020,102300121000004,114000242303001,102021111411014,103003101400121,114210002324000], + 101000020002010: [102024001120110,102100042002040,101203144040034,114000400012111,110230402031010,112000112003121,111420004443424,102211001100222,101020411114000,114142020220122], + 302021402031203: [100032024201210,100013401040442,103012134011120,100031030004303,100000010413400,100101132014001,100402230022321,112000433232220,111031200120202,120000221031424], + 104202020010222: [111133110023322,100400024103122,101024401112120,101001440303020,103002224002043,110140141201202,112012030233024,114201004001120,101141004004210,100201034224100], + 1020001101204040: [110001041213031,102300324010203,102100142002204,100030020011022,102040011121100,111202012222402,111322234130000,102040041320010,102402104022000,110104002010100], + 1131110444001010: [103001001400034,100121021040101,100000220100300,101014000340100,114110002344030,110140001222103,100002131030310,100242221000000,114010310044021,101100010302424], + 1130222304201220: [100102004100201,114040204014042,111230032242001,101221031020331,102324031000000,103230004030322,102102001341000,112021022003301,114024104032203,101220004012040], + 111000002001120: [112413224040101,100220100110400,101200031020230,102403004042342,101024001034211,111122004101222,114020040013100,114001012300002,102121100232012,114000222213021], + 101014121202200: [110132141121031,112101020422004,111223110004240,102030140000022,102012210222441,110201031111320,100000224100002,103002001430230,102032021100000,110403031140001], + 1010010041040014: [102011201101012,102300304110030,114412000003141,114120430002002,103020041420212,100112011040011,114033300041020,101201220300012,100401024300321,100102030423010], + 130000214020102: [110020100042220,102123000230200,114200302320443,100401111000221,103302010140122,100010001001122,104240202023232,114000022210140,103100420210210,102132004132023], + 1010400101301001: [100012320001320,102000331120104,110203111111000,102323204112320,100420404320101,110420220003321,112401014040034,110021200002102,112000001112010,100402130013100], + 332000324400011: [102120010220042,110103312142034,102210210312302,101120100320100,114140014100000,102110004002301,112022100213011,100101231202322,111210020001013,111300142204300], + 200211104401120: [102111000202241,103202404031100,110043132100220,100040424310002,110000314202042,112421024013100,100402002200010,112234224002101], + 1030100100203131: [101012400343401,102002100222202,101000410321210,102140021410400,102001041100103,102202334040220,101001100320224,114021004100002,101300201001300,100123310031000], + 1000130022310001: [102101240210242,100210120430000,114242114030210,111223420000020,111000324414403,114303400002424,112030302000110,101033114001203,102121114002014,100102221200100], + 1101010033020000: [102304420211002,114112132313033,100220000432400,110100104220021,110000314200200,102240212002402,110101122013034,100030124100010,101100020301004,103120011241010], + 1001002000301024: [110202004211120,110223224433004,110341010044330,102031144010424,100302420120212,111212114131222,102140001441301,102221010201113,111012030022123,110031424214112], + 124020101222123: [101212040011001,110201344402000,102312010211010,112312201131301,111110223004100,110020212130021,100120041224204,112410012010024,103004024040430,100212011200123], + 1102042133010202: [114400034122341,100001101023021,112021201120101,100001000012021,114002004033124,101000104002203,102010231120312,102101104000212,111120010020104,102100230210011], + 110402133220242: [100142004031412,111031100022230,103010100101110,101102210330301,100020141040100,112241024013010,110110240001000,100002020112431,110320020011000,103441130124021], + 100100110421102: [112324002020202,100030124210101,100011224100020,114203224111020,110104100401324,102140201410013,103010011434004,112132012010003,101012421033020,100020101001010], + 1030112042004000: [110233022033303,110103000003010,111110202244311,101010021142414,100040024300430,100122341022200,114102002341430,113400321012204,110420222224222,100000004311204], + 104220121000000: [114230310212200,111242000003000,112003020221100], + 1124012222041000: [100440024301100,102022200220022,102042031102112,102410111110002,100101041040330,112122334022424,102122000212204,100422021002002,103341124011404,114010214101003], + 110102200430020: [101010034002013,110001111011031,110021304203102,110001440041003,100203011004130,100114104000040,112401000200040,110010411100002,101201030303200,110101021201003], + 1404032012022301: [101044214042221,110010114210202,102141000313022,112401010202200,110024010120300,101122001110002,114102002340031,100042201033001,102200011300300,100122101200000], + 202003040043200: [110020301220324,100041000010302,102020100243032,100031001020040,102012200202303,101110404021211,103110041442122,114042014102321,112003110242131,102112222001200], + 1000000124100202: [102040024001221,112201014002042,103133211444022,102102412002340,114000122212010,102212014031221,110024222100001,102404000230440,112202101103403,100034331000033], + 1102000043020004: [100212201000030,110020122101104,110040002132020,104130030010110,100000010411400,100000000120200,111120112103420,100100014000020,112402144042221,102100340232410], + 1010210200424013: [100013104102120,100002300012411,110412221244140,111200012201041,102011011321024,110010114411020,102120200214220,112002124000132,114024220020023,100423200030421], + 1021121020030343: [100020021042003,112404212020403,102100021341110,100002000100120,102102240210112,103031041400001,102022412000010,102300341002000,114002304100240,101000011003244], + 1032114104102004: [102012021321102,102141000230042,102002000221000,114044020020230,102000230224024,102321001000211,102242130202110,100010001040020,100002031020102,110200440000121], + 1020240000234201: [100000230100001,104002001220203,103412114041002,110011342000301,112141142310201,110121001243423,101000014000420,111001032141000,114000212242130,114002200020100], + 120121212420000: [110000022003412,102401200232302,102230221100001,100112224301402,100011100102010,101322224220202,100003100011100,102311200240102,101212020301403,114200302333202], + 1111011000340243: [110322104424202,101202421002031,102102220312102,103004204021310,110012310020200,102030130241300,100232224340041,112400002011010,112011001113222,102240134031142], + 222101023221002: [110102224201130,103301201402204,102401121113302,100021020124002,111201210000103,102104131412412,114020312300021,101320040302031,102400204043012,114010102300010], + 1021200031004220: [102420011111224,100020004300114,110422402022230,100000000413010,110232020002221,100200010434020,102013102002210,102101300311032,110031332132100,110010021200102], + 1010120202320000: [110310422104304,110130131203320,103100214000113,110001104210004,100002421021214,114300212300001,103030441240230,102020411100001,110210212110310,100101020411004], + 1412434230011100: [102320104112023,100001034102143,101201000311021,110110414402000,110300112001013,100021000104412,110110211200222,101003301110132,100104200411203,101100001100404], + 1011422222100021: [100004401212000,100003034100001,102000010200014,102110402004000,102123242001200,101000040343001,114120320224032,114130112310004,111320340001240,103200201400040], + 1124231320342010: [100002121043000,102400234020130,101202001022000,100133204300040,102200031002000,114021112304224,112110044020204,101201101001302,102301204110230,111214012220202], + 100033011000000: [102430231400211,102004021102101,112002012030102,114440240003000,100403200010022,112120302010202,100020010000104,102124200204223,112003011123014,100000004310100], + 1402102334230230: [102020314012030,102020224000000,101002100323042,114021040001000,114110000002010,102301141002223,102110300210002,102000314012111,112014010202200,100000000410010], + 110001340230023: [100020124300032,103000330110013,100011210411120,1000301003020410,110320044420300,110010004201031,110031340030431,100130200010403,111202324133101,103010034041210], + 122421040332210: [114413122323000,102011232000334,114013314033010,110003202130040,111120310033010,100400410020001,101010401010001,111004010022020,100100201001010,111004040000001], + 130004010200122: [100022102100243,100013230100000,241221402002000,1030200104020421,1000102021230333,110344021203140,4002244101001011,101212413013223,100004424041022], + 1110000020202002: [101011010320431,103041414001042,103220000104122,101401030302440,102040124010141,102314221101100,114240004002100,101404104022202,100000011233203,111310114130114], + 101402140240220: [100014011034234,102240221000001,100000324303120,100221200002204,114000024101102,400200234320200,100020124204330,100101011013002,103002121432200,102141101410101], + 201042331220223: [110423144220412,111111032211400,103310010110323,102110341342110,100210001002200,112240241104124,101202300303044,104134120010200,103112124000010,102020010220120], + 101100202011011: [102100404023424,102202201120000,100012200101131,110032302102400,100140204233112,103030404010000,112414042011121,103403044001110,111012020040441,100400120022300], + 1021140013312200: [102240120244002,402010003200010,101003204000004,102204424033103,112010412020141,1002001101203410,104223421402434,110020102120001,402000143220001,123300114110104], + 1023002010212103: [100012421020214,102011201412140,102100100220230,102000401130003,102000211410100,102331110243203,100100340022200,100100101041000,112100422011011,100112210012241], + 141110101402042: [102021204012101,101224131020341,110012211120424,114001214100410,102231301114002,103210220100010,103120144004432,114033412300220,103112241441002,100020010122220], + 113300100202010: [110032211204214,111010204401023,103142444002002,101200010300001,112002132303300,114420232314210,110103101002440,100301004321221,112432104012111,101104100331011], + 103310040021101: [111100114401014,110003112130100,103000230120042,110103011302220,102020440242023,101230000302304,103222010114132,102300121004102,100042024100140,111322224120002], + 1212010000200442: [110020301220324,100041000010302,102020100243032,100031001020040,102012200202303,101110404021211,103110041442122,114210400000112,114042014102321,112003110242131], + 1012042300200011: [110011232100412,100220040142222,110232002101410,110020120040121,110200021210212,110100100031014,102401010202301,114240000001020,102112004001032,102204114114214], + 200020300100100: [101012324214020,100000041041202,100000004214210,100120010020214,103411120100301,102110211441000,100402110020100,112000320221241,102100120311400,100103301022000], + 121011120420001: [102223111000042,102320200221110,102140041342420,101040401032021,114200004110030,111102324104110,102000324013042,101301420312101,102330324110001,100010144101222], + 1100020002201214: [112211122030420,101031201001231,100010021034321,102000010202042,112013012301132,102001104001214,112100140200020,111004410022000,102023224000110,100120421004010], + 200022101140224: [111030144113100,111024044110202,110001000034023,100001204102223,111120120020010,103141000210223,111041104111423,100402120033300,112012304003323,111000122234002], + 102020011224440: [103342200140020,101002204000401,102102010210032,100104100414031,103202320101211,112111342310011,120203030102301,100020014313110,111042022231040,101002241110012], + 134000140103000: [114202130211223,110110242112211,132210024001013,132104221210012,100033114200011,140402143000011,102201130200131,111110100010302,102233402023133,100114114231141], + 1021023241230202: [111201032220400,114203000004300,100022120412132,100000321031423,110322100104010,100102024100020,114043002302200,101222121020001,102120230230000,100032021041010], + 1033202000022202: [112021201120101,101142124022010,114202002320113,101000104002203,102300014110023,102430001401230,100402120031033,102103422004103,100010024202200,100020004212223], + 204020230202012: [102101324130010,102100441341013,101440004042202,100100204101010,103312401404300,111141312211004,114002134022331,102020014003003,102000000223101,100020024212001], + 200210303004120: [110020001310000,100310201003000,110412121110214,110142300120000,112010220224003,112001040231401,100200001001300,100012104313201,100002201032401,111301332200104], + 310140200400000: [103342200140020,102321301000010,101002204000401,112001030221202,111010102203103,114232034002001,111320004120022,100104100414031,103202320101211,112124311100114], + 1103040221113200: [101440004041120,101031214000041,114112020212203,114302020003041,102110014030002,110201200000101,110110000032030,102001200204101,102033340222200,110042402132412], + 1104043040012120: [100031034311401,100023210021210,102100104000203,110200101200402,100000140100020,102021201410011,103211014030010,100034124101023,111010024402022,100212221002300], + 1000001002330021: [101440004041120,101031214000041,114112020212203,114302020003041,102110014030002,110201200000101,110110000032030,102001200204101,102033340222200,110042402132412], + 1004240110000403: [111001210042130,100001201020430,100422020030044,101020401034001,102440214020040,110001020021430,100230241000000,110102032010323,114330004032011,111414104421003], + 240330001220102: [102002301120010,102340101000014,201301011030444,111002100000102,100012034312220,102004014000430,110140332002220,114111240032010,100431240001030,114222302321101], + 202130320200132: [102300324010203,102100142002204,103000011402201,110113004402201,100030024303023,110301232000100,114110340004414,110303401230040,102013412000213,102104020202131], + 132042210002042: [110104112010103,100122004300410,102202414041044,114443330001442,100230120001003,112203221102231,114022400020320,103001104010010,100111201014214,102003000220111], + 1400024134002001: [101104121111010,112012000220013,112030022000220,110022012133400,114112112341240,100112401023100,112102420203002,100003220022000,100100201000004,112400124040001], + 100021042220040: [110020402002300,110200200400310,110000011301000,110013001200012,102341101101130,114010000033220,102100014000101,102000404021220,100000004102242,102412304022012], + 1011010320310221: [101220014012231,100104024303320,114422004110130,112210132031001,102010310213001,103244320114100,114242312322020,102021221120401,100121424231222], + 130002001402202: [100024234201100,102113300230021,100010044310002,130000420243230,100232104120201,102212234021233,100100341202102], + 1000002100003011: [100332010141200,110231104241010,100020044100330,102020401120022,114021102203101,103040230101104,112004040221232,110010020014000,111010042201301,103022010141100], + 1020413022423210: [101023211102101,102022001101234,114220102332012,102000304001202,100010101021044,101233100300011,114400020001022,100001314100400,112101201102130,101004040320002], + 222114100000021: [101131004020022,102004311130001,112224202021132,114002242303403,100013400002001,101032331001214,111100004100002,110001032100111,114104222313030,102433241111002], + 111144313000310: [110430430003002,104412212102010,111012104400010,100432200033101,114244120001041,101021020324310,102340211000200,103120140210020,110010220000210,114420230000240], + 1211000011002303: [101200400041032,110003000042343,100001034102143,103001224014142,114431224113420,111211002241330,102042031440222,101012021030223,102304000241010,100004144212300], + 1000402010444101: [102101320220430,110101001304100,102320014112013,102312010211010,100111120012323,112312201131301,100023100104410,100000011041021,100024000010031,114010404102102], + 221011410020010: [100020024300411,103001321404030,112000234001001,102242041114201,111102200020120,100404000020123,111000304402300,112211131100120,110102001001100,102214331110104], + 1000100031003200: [110102042010220,101020124000413,111210000001101,114013400011030,101201104040034,101020111030400,103004104010210,101220024041000,102010300201414,100202200003011], + 1120000122110300: [110101231202300,100130444102110,114132202313300,110223310000311,103010304012101,103103124000111,102300111104023,114001304100010,100400122200001,111100414100413], + 221333210120002: [101232314010241,100301300121100,110042400130000,103020124010320,100021300101201,110230022122031,101000444214021,112102112301130,101244324043222,112102232300222], + 1020123410230010: [100140101044224,101120004023340,103040031403031,101000211032200,102200010202110,100010044300131,111010130002222,102030021130002,110200300000010,102040201103400], + 1100042240010010: [104100111240003,100010101020412,100001200100310,102100200221304,112022131130201,112332101100224,101011024001101,100430000033004,110003004210404,111232402242032], + 1424400042000411: [114231202331202,100003021234044,111102032220111,111300042200340,101010041032322,114020042300022,100021421020002,102400004040100,111120204100203,100122101040022], + 320441024033203: [102011121102202], + 1410100223123401: [110201012032242,102011001134111,114102034001211,102302011002003,100314111000314,103222004034100,112401420204002,102002101100313,100000211001010,103100020102004], + 100011404400020: [101224004040224,112014200203300,102101300233234,114201104110402,111330000011002,101010211001223,111001004410120,110221000110000,100120241012042,101200001200044], + 110322200421322: [100210304340400,102201032021231,112020044000400,111201314412204,102000200204141,103220100102140,103041130110112,110023014202232,102220021304234,101023011140000], + 122140021013404: [100221304220024,100111424233042,100202021001020,100000031203140,112202140204000,100142114233420,114320020000000,101100131114110,100100240003022,112122122012102], + 1044121000010000: [101440004041120,101031214000041,114112020212203,114302020003041,102110014030002,110201200000101,110110000032030,102001200204101,102033340222200,110042402132412], + 112000400342041: [110021000410432,103202000110102,102020440220202,101010010320112,100042000000000,103101024004200,112000021122010,100021111043012,103024000103302,103300021402104], + 1020041111300010: [110000220420304,112000014000010,101100200334040,114020410021402,110040000001340,101020004002000,110032002131000,101431404041202,112000204001204,103122301240101], + 1124210320022304: [110011011212100,101134030011000,112000244001222,103220211421421,110123230124040,131000001020102,112200412033030,110420001000202,100102110402220,110412310030001], + 1002204443010220: [100122004300410,102140014001101,102000104012232,112400202020003,102000224000011,100011124202310,100030300124130,114400202310210,100001100013110,112233332034000], + 130202204000014: [102120010230031,111202300010010,110011200022002,102020304000242,110002400023342,100120044233220,110023202200020,100020010423201,103402201212100,113031010134002], + 1142104000424200: [114022300022421,111210044410020,111420230003130,101221000312044,100400240013333,111001314111000,101031030300001,103100040210040,100210001002200,100001210100102], + 1220140432420213: [110020402002300,110100104404110,102110042001043,110200200400310,110310100011310,102204001111220,110000011301000,102000100220240,110013001200012,102341101101130], + 110030401041223: [104100012102004,110030002000422,102102011413000,100402431012022,102403404004110,102031024013013,110044020020202,102122410220401,110021232000021,100001140000010], + 100202100020220: [102422114040010,100022041001002,101204400304011,114032424122040,102020004001311,100101101010100,100301020420101,114103212312012,102321044112101,102002202000000], + 122130302202301: [102123220220223,101203342123110,110104102010242,114004312330330,102012114001113,101321004220102,103132114000010,110001012000001,101000101004001,101011040322103], + 121002222000430: [100030324200410,102110202001010,100040041020102,114200020003431,114041002212302,101002200343110,103332044032320,100212024322044,100140004102001,114101024122320], + 1113421030104124: [102300321004202,103003441432012,102311410222022,102000401410111,112000112001400,114310020001120,111101304101024,112240000200001,101021010300000,114111000233241], + 1000330000414003: [110020402002300,110201012032242,110310100011310,102204001111220,110000011301000,102022020202210,114010000033220,102000404021220,100000004102242,102311011001213], + 143302203221012: [100310120141002,102324014112020,100301421002002,102404021403141,103022021431010,103200020111014,100010004313001,103104200210410,100002200410030,100121031014040], + 101000000030200: [114233210000201,110033032100000,100002001024100,102103130221330,110011002100114,114102220033034,103303041402240,100002121021022,100020200012311,102120100220224], + 110400203132431: [110101201003142,102124204002001,103020200102104,111002310022022,110102000024120], + 1440010033102120: [101020414010211,101142004000232,101410021100102,100110004101000,100040020201004,102000034000000,112400200201000,101212310301011,110402030400142,101023431001040], + 202010224022200: [112001001112001,100310444310004,112332000411020,102431200203321,100211001204102,110002400042003,102032010241003,102403204000000,112333412022030,100210124104100], + 222104300412143: [104100012102004,102102011413000,100402431012022,102403404004110,102031024013013,110044020020202,102122410220401,110021232000021,110301322104142,100001140000010], + 231011000200004: [111102110012000,103220011420242,100031201030331,100141011011032,100002120200101,101000344010212,102100431342023,101033141030001,100104400021023,100040300103443], + 1432100024112132: [111000010041300,112000002003301,100200221000243,102400044023410,110423034242000,111204000003031,100012004110024,102142000210040,102320214110001,102144241343120], + 1024013200100010: [102040431121110,101221020040220,114111100021420,112024212301420,102212000200124,100300310140241,100240134323001,102141212000200,102042000222002,114402104142102], + 110132320110204: [103100130122100,102340011104001,112300002022101,100430101012411,112013212002212,100202301000000,103411014002010,132000110000001,101000000300110,103000204004020], + 100041410004001: [110041240000013,110131122012210,114010200040441,110032014420232,100012044101230,110412001213211,100000344100100,111304022202211,111021212200430,100021214210112], + 304200240230404: [110001041213031,101110044200100,102411000200000,110414300030001,100030020011022,114100122342002,111202012222402,102000221442214,102040041320010,102402104022000], + 104240041010003: [110001030120020,102233034000002,112130004021000,213002142300033,111212024101031,100222240004231,102112314002011,102241414034000,102223001303020,102320104022204], + 302212022410010: [102400010200011,101002041000124,101413321300222,1211200120132310,110222202033213,114310224030143,102031011130110,100302001002031,103304201400304,100011040202101], + 1002021000441410: [110104112010103,111102004100101,102202414041044,102140014001101,102000104012232,102021100220101,100230120001003,114000040010421,112042110220004,112203221102231], + 112120022123420: [101222101202341,100020220410142,120202201010210,112042024000020,110022100044100,110003000024101,100010024302100,100000011020412,102022400210202,102003034011323], + 204030001023003: [114202400003330,111201222220201,114201102324001,114330004003002,114404022311000,100020021022020,114200002321304,111231042242020,112100204041010,101420001010224], + 140100100102023: [110300202021130,101300231002120,103400104001022,102212200313103,100240020430431,114440420003022,110021010021210,100000024302220,100222021003140,100102404232033], + 1100102034330004: [100020214300031,101010211001011,111220030010210,114042034104243,100004030411141,100412030034000,103232114040140,114010002240111,100240401003203,100002220411002], + 120102200313403: [103201411402002,110022000023010,103101224000011,114020302300110,111002100021022,102302120210122,103002000104400,114100032320203,100400300013000,110114021000012], + 322030102010400: [101301014221122,114220040000201,102102204022310,111040032200021,103030040121410,114040210022000,100404400013222,112010420241002,112201010203210,100000214310412], + 1012320310222003: [114020000020001,1302101004142102,110001001100001,201014000241421,110400102312140,1043303323011400,1002000010441103,140011220320300,114200022340011,214301004122000], + 110302001004001: [110300204431104,411200142040000,101040211000300,110413401240204,100222100030130,102120402001131,100312401002102,103110001420121,110102112010100,112040022301012], + 1001313302413001: [110010220040411,100010021002314,100022441042300,103100111424040,103100104000230,100303021002102,103020040142112,103210001410031,102304000242033,114020200011020], + 112030010210140: [101011220324041,101300000310200,114220110001121,100031004311400,110020011223233,110013000002041,102220004001014,102141302001013,100401302200302,114200102320214], + 130221000143204: [101222101202341,100020220410142,120202201010210,112042024000020,100010024302100,100000011020412,102022400210202,102003034011323,100003341032400,103211031422023], + 1132300231224110: [100002021021021,102401004021010,102402000202120,102124004023202,110002100012000,100001104210032,114240102322101,110033301230100,110200202122114,100001100400202], + 1030030424020010: [102100102001001,103113201442104,1001221041001000,100101131200000,101014020300010,100130210421420,1302024401111213,100100014220442,1034022001022241,313010202340021], + 220400111010022: [110021130023004,103004204044030,102314321001312,102023232000102,100101001010214,101141200014120,103110001240102,101202000300442,111202012241223,114010040023121], + 102212121101000: [102142210212103,102310201001230,100102111040112,103110000104002,100023020410230,114121124120244,100131401010130,114310104001300,100032341030204,102342400213200], + 1130204101000020: [100310020420020,110012112012000,100401101012134,102000000212042,110000212102200,100100101000220,112403200202210,112044040201013,100404312200011,103110144002110], + 1001214432401203: [112404212020403,100002000100120,101202301022130,102110302004002,102100011413332,100112101042131,110200301301240,111221110000021,102001004000102,100010000121214], + 101110104000014: [100000100100200,102010020203010,114403210004014,102200010200000,112102100423402,111131232212120,103211301411024,114444012310100,103140100210101,100020200120032], + 1100432220020331: [110020242002232,124204140102230,100032400410212,100001120412222,120302031123202,101220001020114,102422300002323,103122024001010,101114304000100,133231404422402], + 1000212040002000: [102110000210300,104220041321240,114420000001024,101021321034010,103422421110341,102040300202332,100112044302010,110030140000021,100300030421240,102102201341101], + 110303313133210: [110110010022302,103000431240102,114011004114100,110101140002212,110420000104020,110410140000110,100000401031111,102004101410420,110204242124012,110022301301002], + 100002201402300: [102310324112030,100410130030232,103220101421001,121110020100002,100002104204000,140004230143221,144200400000000,103321202010002,101124344200400,102021220202100], + 223321301031124: [102200100200422,100030001033001,112011122004000,101200301010101,100020040120103,100102234101014,114143412200020,100133000101104,112100000420340,100002010100130], + 104002002222221: [110020001310000,100310201003000,110142300120000,112001040231401,103012011412220,112040101120100,100023234310410,100402010010244,100102434221001,101001000314122], + 1000011022024030: [100422040021304,102000024011300,100002010413410,101011210300000,101433010300204,101002221140440,102040021424212,110324444424432,100100001010020,101000000322000], + 100033011001021: [101001040340004,102424204043100,112022334022101,101011324004222,101410401010030,103210241422022,103240001403000,102202204040220,102121010212140,110020124200230], + 100232002132304: [104011021220100,111040000020010], + 1122034232200040: [114201204111222,103300004021200,102004204041000,103230134011412,100012004101221,102301101004100,110432112111103,101410020300143,101000100342143,101012111001103], + 123302021211004: [100020344302010,101000024004442,100002100000100,114100102340003,100100414230101,110130030020000], + 1001400330104400: [110131214220303,101101200311102,100200204123011,102012024040044,100042021022002,112000210230234,102020104000240,110013120101010,100404042201022,100104020004002], + 1000040032000101: [102100211412223,100020010120131,130022004024002,102400130203000,144112000040122,100010000210210,103034444000240,111110423020020,121021010114001,114142033030202], + 130010004011422: [110412001240302,102044001440122,102400304042142,102223314042002,100110004103103,101004204000013,102023120204401,101003444003023,111120032214004,100200020012000], + 1014004200102344: [100432200033101,101230004040022,114244120001041,101021020324310,100020140121034,102340211000200,110010220000210,114420230000240,110414012023214,114021000044211], + 222020221310200: [110232011000001,102111301413000,111000212203022,112243004012113,103130101240011,102024331121001,110014024412202,100000010400422,110022022200130,111320232203130], + 1420302232040040: [102101021412120,110024020421011,100042014310200,100003014314102,100040224102124,102100011000033,100011214102010,102112241342203,100002004200212,110010332201012], + 1404002040004022: [102040431121110,114111100021420,112024212301420,102212000200124,100300310140241,100240134323001,102042000222002,102001011100100,114402104142102,100030010102102], + 1011230340000000: [101302134233230,100022001040322,100000130010033,101030404212000,114102224000201,110020030024004,100022021041122,100013011020311,100120041020012,102012204000242], + 1410040223010244: [101002204212400,102001004012002,102112300201410,100100121043010,102100240231342,101123110330200,100323120143000,110432111241204,114200200002223,112123142010120], + 1422130012420011: [110022004410312,110400011243102,102000401442010,111020004400234,321114010100340,100121041041101,102322101000200,101020041000102,1042012320010021,110413131000201], + 222101000000044: [114213002340022,102120140212001,110102030010210,114400210002021,100240011000013,100000021022400,144200203310100,1003022312322100,102001244001224,114213004000003], + 132201220024002: [114040300043111,110203111111000,114010030024204,102010201012014,102041204000002,102323204112320,100402201004014,100420404320101,102123414032304,112401014040034], + 120040202211130: [102100002002024,110014002130003,110000010021010,102010344000024,110102144200000,100212004104211,112200002020300,114203302324202,101100004004034,102001434012010], + 111023100100002: [110240301111040,111123014100000,101042230304321,110011020002013,114200000003241,103103404004112,100200201000403,112142011101404,100110120023012,101042044010040], + 1030222410300121: [100202000030042,102202131004010,103040004012200,102200142000111,103220101413302,101420240302103,102200114011100,111314100042040,110020120040202,110224010010021], + 100011112004121: [101121000330012,103243011400102,100024001220012,101400010300020,111122004101110,114414020000010,102400000230200,114112224002020,101104010330200,100341211000000], + 1432101140002002: [111100114401014,110003112130100,103000230120042,110103011302220,100101141042243,102020440242023,100220010002421,111210240010100,103222010114132,101240204233201], + 102221100401443: [102012210222441,131402001003121,100440420024144,102030414000201,100304111000014,103300031403210,100022131043110,121041101020014,102301201200000,120003002411030], + 1113110002212000: [114130012310000,100100411041000,103241131401223,100021221030421,100400120013011,102232024002401,102202141120400,103011001244001,112033112003214,101211000301100], + 110334201200020: [110001332120300,102101211411000,110003000420200,110243234240200,110004014411012,112000120232022,102041220200010,100002320113100,112240200202201,110020321120011], + 102042002020311: [111120030010031,102021020221104,110202312030114,114012042300202,112001112310011,124002022040202,100121410011340,110020100040110,110201014430001,100011130101220], + 240233100200404: [100002100100210,100400002201113,102420424042020,100010001032223,102111024000402,114321002320001,102200401111200,102000430221040,114003104031111,100100000422320], + 130012224021230: [114343002322014,100022314100104,102130314131401,114100022342130,114300010002100,100013024312024,102002020243020,114002002300201,102040021121030,102102211140013], + 100330021402004: [110400124241011,112104034022022,114233300214304,111020204112021,103022444011022,102101101021304,110210000000040,100031324100010,102202000232032,100040004202102], + 1110002124202300: [101033101002303,102001104010010,112002030210041,103134244000000,110002102003311,101011344000022,100041130040040,112402334040422,111000030042302,111013004412334], + 1103130042020020: [101210320301302,102100221340112,100114104101001,114002244103320,101023221000031,101400014040400,102012034000402,114221004002212,102100122002001,101000011021414], + 1014202222322000: [101011011000320,114420200001202,102200100200422,114110012200230,100000421021024,102020102000000,100030001033001,102024144000240,114121124124301,102102002002000], + 1420031100410010: [102320130240202,100034100023401,110140042002031,111001024132202,110010132030102,110012000002021,110223102022103,110141041304241,110033021204221,110120100000300], + 1040000023012002: [110021000410432,103202000110102,102020440220202,101010010320112,100042000000000,103101024004200,112000021122010,100021111043012,110124041140000,103300021402104], + 1030010000221111: [100003211020020,100000101040120,102300000220000,102323320240010,100011200100023,100010044213301,100122124300402,103031114000000,101233124010023,102400100201130], + 201022242102413: [100020121020300,111110010022310,100200001001300,100002201032401,100240010430203,103432001210300,112440134041000,100210240013000,110401214242400,100033201031241], + 202340400102321: [100020121020300,110412121110214,110142300120000,112010220224003,111110010022310,100200001001300,100012104313201,100002201032401,111301332200104,103012011412220], + 1013140101010012: [102010040210212,104400301202200,100030010000110], + 1011030010402001: [112113214020100,103300344012201,100122200012014,100000130013400,100011200201400,100001321032243,100201104224131,100002100204114,102211430202033,101031321022412], + 120240402131302: [112000302000201,103013140100312,100000424301231,102133114020301,100234124224203,110032224202331,100100030024102,100044010000141,112043200240400,110022000133124], + 1141001131414123: [102301201004041,100400122200202,100124001004410,100020024242001,114300122321020,100120300400022,110040012100142,114302430004110,103200001200010,101000000324014], + 121003221210302: [110330400010040,100101231004020,110013112004021,100143040411011,102404404004104,114002202302000,100034000000002,100400100031022,110020130044232,110333010013100], + 100040410300200: [102011001134111,100000344100100,114102034001211,102302011002003,100012441030002,101022114003000,114024210021201,102323014020022,100314111000314,103222004034100], + 1121004120121020: [110210114434301,114220024004132,100020100101101,114230012340300,114100022310024,112002030232410,111123224101232,112104020200001,102222001000203,101104300332343], + 120210040211010: [110114001202122,103034031400131,100001010100220,114002114012041,102000004012011,110101100012002,110001002004240,103322000112244,100030220002102,114010000023421], + 100120401334202: [112002002000410,102221230200001,114100212200003,110001040443212,1341242223200002,103001044021102,100020011230001,100023201000300,110420034220220,1010001300240320], + 110000000103000: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 242010100022001: [100422000031421,102220021120430,100102000010243,100024334203210,103031410122401,100040021031201,103000300120001,110100000100314,112012032034400,114043010040012], + 1042023313300310: [104120011242011,101230114202200,114300000000002,100400000020230,110020002104100,102111400202120,102000301101102,114100124002210,112400034040002,100000020201032], + 1401144043023210: [103004204044030,102314321001312,114111042314242,100010031030401,100101001010214,102334004110210,101141200014120,103110001240102,103000000101400,101202000300442], + 310040013312302: [431013031000023,1411024442020100,1002230121400101,103020110002104,1300100202010022], + 100004014223100: [101240210310204,100200011002200,100211041001012,112200000201104,100400010022002,100234124120220,110030010120002,114001024011341,103003041221441,111003212230033], + 1020102311100202: [100014030122001,100340204310400,110302220011010,112143002312100,103000121403344,111210300001213,112041004000223,100000221032000,100220320410004,110121000403344], + 100041030110220: [100242024100001,110410021002000,102000114002003,112042012000041,100020034311000,102041120220020,100010030104002,100010044103130,110040002120031,100001241033300], + 114022000201020: [100110034332223,101223100300200,100001130001003,111303214132004,112000000220402,102204004042041,103001201221020,102120231403010,110200110000022,103210021401242], + 1100101312431001: [102423204023200,114114010021023,101000000320000,114220212340004,102202000200000,110301004420202,103140244030030,101402114043020,111102024102110,112000002000300], + 202324010321110: [112014112303102,110312000010412,102002121103100,110103022012204,100214200004002,112200034012002,114104114000202,111201322223442,110024211210210,110003411213000], + 200011401213020: [102242320200020,110030021222310,114010104030002,102010011011210,101041020321002,102013131134030,103312010110013,114101042313041,122112024242100,121211001014412], + 134012304322131: [101022014222024,114230004110101,102142002000030,114000024101202,114201024112001,112020021120403,100002114104410,102130314134001,101043200320000,100103120104110], + 210230140104000: [103100221440010,112202000411103,114003344011001,100021101000000,101014201030204,101203001010111,100031201030102,114201104114111,101041001003300,100001100411302], + 1040042210202022: [110120144200000,114022412330004,101200221022044,101041030320401,110241112020204,100002004104004,103130021444021,102100104002224,102100224000210,100014204201000], + 101001400020000: [103111001422000,102203004042010,111244302220204,100042100102211,101114000332010,112112211102024,100142044103021,114004014011110,102410004024030,101100010012423], + 220021202412120: [110104112010103,111102004100101,100122004300410,102202414041044,102140014001101,102000104012232,102021100220101,114443330001442,100230120001003,112042110220004], + 1411002302000011: [114200212322001,100401210020002,112210322040121,100402042200000,110001440041003,100010111022102,100220300410430,102000224000000,100002104302110,101022440300020], + 1040400303000130: [114220040000201,111040032200021,100404400013222,102241044033231,110000312201003,103042320101230,103004004001222,100311000422101,101402031011101,114130004101132], + 112102200421412: [100122230031414,114222042332003,114011120024030,100101121010100,112304211102104,102440024021100,110110420034120,100203304122231,101100121020020,112023032001201], + 130130011420024: [110240301111040,111123014100000,101042230304321,110011020002013,114200000003241,103103404004112,100200201000403,112142011101404,100110120023012,101042044010040], + 130202004011110: [103102300102243,102113020210120,101012310342300,114020404101101,102321320224101,100002404310212,100020004310022,114012212302132,100003100122232,102000414010131], + 1000123012130031: [110001422030011,102144314002302,114200112340002,102343014022001,100211000430431,102240320200212,100140200410200,100020020120200,110210001214000,100001024311400], + 212130134000202: [100400001001300,102000220220104,114202044111100,100030004102002,103110114000220,103200021402002,114001200041204,114020114010322,102030401014002,101232444041012], + 131130004121201: [103300121401234,100122200020013,100400320033201,102331104112002,110121112010004,114132002200241,102330144110211,110214202124100,114243004003002,101200004233120], + 113100422304001: [102442211414022,110401440001204,114400322311044,103224401422304,111231012220013,110022300420031,103214220100013,102340301000304,100023011030111,100101220101011], + 1000310040114224: [100400224300040,100000020001023,111144042240304,102141201342300,102140210230000,101001004012413,100220121001003,100002001020024,103321024020142,114023230030204], + 232102014421130: [103241000112010,112020104001300,100034114100102,110330002104200,114101012201420,111032414402324,101114420310142,101120244000002,101300000340401,104240102023211], + 1001012022404232: [110301402000211,103030201402004,110420104221220,103200004030020,100320014310021,102000110221110,110240214432004,102122141142000,103041204010000,114432234113040], + 100012142330110: [103000111421112,100110001000423,111000000041000,110211010101001,100403132200002,101400004022000,101022440331440,112030011121003,101120100330133,101041001022001], + 1001241211404240: [101002001110304,114121112313010,102331400243022,100003004241212,102300434110131,102020021100000,110400431340433,100112004032301,110300202001421,102030001134223], + 1011100420200022: [102012201321104,101002011001110,103012301401041,110043034212101,101001301000011,101200034044124,103042224001110,102110040230322,100213100410301,100221210412004], + 112102000201110: [100010424101430,114000224101044,102110022001111,101020301114001,102102300210103,103024011431131,101011324001431,102320200224120,100030014210012,114100300000120], + 120011020000010: [100103301002044,100040104331012,102240041122001,112102010202000,114213304002022,110020200030000,102001001130003,100030004100221,103120304003121,103141021212342], + 1120202112004304: [100400002201113,102420424042020,100010001032223,102111024000402,114321002320001,102001011100100,114402104142102,102311120222404,100100000422320,102100012002000], + 131203130042210: [110013202003320,101031241000010,110030332100203,114404232310120,100020010200022,110011300010031,102300010221010,110221021202011,102002040200002,101212402120014], + 1012200000230411: [103130021444021,102100104002224,102031001411010,101400004022210,102031021441200,102112204131410,102300031004340,102312301104422,101200020303202,100000411002023], + 1401140101201040: [102010114022011,103340041403223,114302210010001,114030004104220,102443211401140,100000221020014,102003224000022,100010031222001,103001114001210,100001111201214], + 1122002220412040: [102202000201220,102203011120021,114202400003330,101000424210014,111201222220201,102103122004211,103022230124332,114404022311000,101010334004200,103003040102120], + 1400200110010303: [102000121122000,110000214202000,100040011023003,114223212320410,100302114311412,110232011000001,100130004033423,102111301413000,111000212203022,112200422011002], + 1022002022200100: [112124004022322,111300210014020,102103201320411,100100031043410,114403210004014,101033214211000,114001100024243,111000142201220,114100012204104,110141112044000], + 203010000010042: [110220202124002,110402424222014,102030024010020,104100212101210,101001011114020,111320000001004,100000100010110,100300024313211,114022012202024,112023212001400], + 1142010001001310: [112110020230222,100000100000104,101410204001212,103102124002001,114212004004022,101002224003212,103312304020314,110110001000304,100310110420131,110001200432201], + 200110013201000: [110413304221020,100440000030040,100023101001004,102101000233302,112130010202041,103210210100210,102012404000211,101043004211000,112340340200112,100001000010010], + 142434043404021: [110322011230103,100023230123400,101020031114000,111004012200100,102340024021002,111212140004022,110112202001101,130100014120020,102000031101300,102040001440133], + 1231200400131040: [101012000320221,102101204002343,102010031100000,100200411000410,102022001101400,100131201202420,100220111000200,102221014033000,110040200001210,103100110110403], + 133022010000010: [112101024021220,110401201001320,110034112134042,110022122120212,102102244030020,110041404412124,101032114013010,114102022202301,100000420422200,102000000220210], + 100002200010220: [100430021001320,103214301421201,1000001214032041,102210000240404,114320124031023,114220020213314,114011310043003,103141111442241,112020141130103,101020001101203], + 113102120431020: [114101004121020,100040301042132,102102241341004,103002020101431,102020431101132,100000041020230,102041021121210,101404104000404,100012104210032,102120204131302], + 1002210230221001: [111220204101421,110042120021013,112200420200200,101001010300011,114012020044224,101120014204000,112001024000200,112020012002031,111021022200000,100030120004242], + 1013021210111121: [110020402002300,110000011301000,114010000033220,102000404021220,100000004102242,102311011001213,102000020223021,112024101112213,112003112000011,100010000013012], + 102330200000042: [111121100010021,110310034424102,111240220002100,102101211410144,102010214000120,100024201030210,102010111102410,101000110322242,110100001014311,102404110230202], + 132203124014002: [114112012210120,100400342201103,102242114044013,100101301001312,102122001120420,112212232030211,110120024200104,101431200303432,103204100103414,100130214030022], + 213102202313202: [101221020011201,112310132020030,101101401020424,114030220011120,103122011241020,100011101011002,103010034004303,102101440201242,112002110240403,100100101220114], + 1001222000302310: [110222020012300,111012104400010,100432200033101,101230004040022,114244120001041,101021020324310,102120111142201,110010011212411,103230010114302,110010220000210], + 1022402000420104: [110141010001110,104122011242020,110213401202210,111103310001234,100110441001000,102012104010301,114123014001020,100004004303030,102001424000000,114001400031204], + 1040103010311041: [111120002211010,103122000100403,102023120241131,110014300041302,104103101240204,114241000002004,111232000010230,110020110400102,100424200020200,110321001330010], + 1002022220222004: [110001202000032,142020040041320,114200004110244,102102402003021,101210101010023,114422114140221,114032104123010,114303122321110,101201101023214,100130104300103], + 1041100003000343: [110104112010103,111102004100101,100122004300410,102202414041044,102140014001101,102000104012232,102021100220101,114443330001442,100230120001003,112042110220004], + 1004421031024022: [111304340002030,110102000401214,100100111044040,103140014002031,102024102020000,102224241110003,112003020220120,100043024210301,102014001130100,114022100010000], + 1020001040241100: [111220202240410,102200020211042,110114002004014,100010114200031,102341041000204,101224110303300,110003020001402,100000144311102,110100200402003,114001000010302], + 1111123130020200: [103324024030212,111022412140224,103030304021102,114110004121301,100104100422041,112002220220002,100121301023030,110000130020003,103120321442020,103002144001000], + 1000010312302114: [100002100100210,100400002201113,102420424042020,100010001032223,102111024000402,102000430221040,100100000422320,100102020411200,102100012002000,114221030000011], + 123040011220200: [112032012004300,102000401442010,102000014004040,111020004400234,321114010100340,100121041041101,102322101000200,101020041000102,1042012320010021,102121321410143], + 1142220230210441: [114011002300120,101221004042212,100303111000101,102011101321222,100010001023120,101121301100014,102002101120132,102010200213332,101100320320310,101000004211110], + 202201100220210: [114040210021100,102002220221002,114100234004010,100030410102000,112240334012440,100020124303001,110020200001031,100034021034000,100022344101140,102230400202203], + 1114202003003122: [101002204212400,100111014100342,102112300201410,100100121043010,110432111241204,114200200002223,112123142010120,101002321032002,101121100013002,100132034104220], + 1212242010210013: [111201032220400,114203000004300,100022120412132,100000321031423,110322100104010,100031314241140,114043002302200,101222121020001,102120230230000,100032021041010], + 222110021443312: [112004300230022,102300030220022,103201311412000,111200004440204,110243100000014,102202101300230,101022130300021,110202001000101,112010101111102,114000102304201], + 200003434220004: [102302440220001,100104400403240,100020111221020,110010122102321,110002322101200,102220124000003,101020201003002,100230300001042,100311334020020,112400022020023], + 100101022240032: [110002042230121], + 1433201112213400: [102302340241312,103243130100004,100410410002011,110133000404002,102202000200000,102101224002210,112104230200100,110311232120010,122203322100011,114141142204022], + 1011002002001120: [100023101042010,102112310210202,102330010243440,114042044100403,114221224002403,100013310123100,100022410101442,100024101022010,110212424242341,100101014300100], + 1401200030012020: [112000302030120], + 1003040244002213: [112020000230440,110041014413112,110004002133140,100040031020241,100411400030100,100002000102100,110122000020202,102120221120200,102100211143330,101000221144002], + 100233404043002: [101000024004442,101031104002100,101101230331040,114132100210100,100400032200141], + 104021103122020: [102341411000203,103010210100220,101121000330012,102412000200222,110200402121400,102323020224000,100024001220012,101400010300020,101121101104211,111122004101110], + 1120312242400312: [110023002000211,110031240011133,110010000002013,102401231110301,102010404010110,101002301110132,100122000400000,100001101040302,101400001014101,103232330101002], + 1102132400000223: [110200400000020,100324140141402,103122000100403,100002204340200,110000410001034,103102224034002,110020041310021,110001001200323,110102111204210,103013100120001], + 1004310203140131: [104104200011003,101004201144000,111112000011221,103203101201011,112113410202210,102210001404312,112220101100102,100101100020112,104130211242240,114002212300440], + 1142203133132102: [100200104321000,110000110410110,101021000341001,100021214210112,112010034020230,102103231340304,102100010222101,103021004011210,112001002300431,114212010211143], + 104100320021034: [103001001400034,100121021040101,100000220100300,114110002344030,100002131030310,100242221000000,114010310044021,102404124020040,110020022133202,103220201402330], + 1242110022200014: [100002044211310,110430122111140,104012302104014,102320221000230,101042014003022,1323100312100112,1300001101120141,101141224002302,100402002201033,112011011111121], + 100204432220400: [100101231004020,110013112004021,114004004112122,100100004100200,110402302023020,101432201010330,102143211343014,110001122101012,110212020000222,100030124202201], + 1402221021030324: [110311011200000,102122100201100,110202202032022,101002211110002,101020330314241,102311031104220,111001444401000,110242101314034,114244202322332,110042010000012], + 141200112200130: [101404110301130,102000001322140,110030411202403,102001104000101,100042114342002,100432101014010,110311102100000,101000030310000,111020104123120,102314144114220], + 1012030422400010: [100013204331410,104123000021013,110233030400302,103300201404020,110000400022241,111300400001004,110000321211330,112203044010404,100121021044204,102200000201020], + 100100000030100: [100002101021120,102102012003220,102313114114000,103030304021102,100000101001431,100104100422041,100001044241012,102030420223110,102120200201042,100200011000020], + 102143100211320: [100222004320102,100110004103122,103020200141000,102414034040100,100022304302043,103031300144042,100120010421220,100000111034100,103132114002002,100412200002013], + 233203100000114: [103300014023010,101421000301032,111302012221000,114004200041442,102004010220020,102121122000024,101011024211030,111020242204241,112020300223020,102313304020100], + 200103003200003: [110311002102104,101000040341000,100001024102000,111330004130112,100202144121213,112001032003010,102010020243104,110000042002101,110100020114200,100230101202040], + 1002022022003402: [100002100100210,102420424042020,100010001032223,102200401111200,102000430221040,100100000422320,100102020411200,102100012002000,114221030000011,114200302341234], + 1230001024101201: [103000011402201,110210134244100,102121041441000,114102022200000,110233010002020,111203034103022,102101304000012,114020202241323,110004402131000,102132421000100], + 304001222420400: [101210320301302,100440024301100,102022200220022,100101041040330,101400014040400,103341124011404,114101000221221,114010214101003,100031130410243,112400222021010], + 1004421012222010: [100014001011003,101212120302000,132011240110101,132044444002002,122001102242001,112104401000212,110013401320032,112040011110303,103001234020121,112020212022004], + 202030010141222: [104404322124241,102032031130301,114023002202030,100013401040442,102200124012000,114002120023020,121400013334402,100103201040210,144442110010421,144000213202010], + 1212200122110000: [111121004103434,112203001103411,100212024121000,100001001033200,100221110101420,102441030231300,103032000144301,114002004100042,102102200220144,102001024012440], + 210332202021040: [102224420201000,103013034012221,110302311302101,100000120002200], + 101020012020400: [114002044012422,1240210023303321,111011220004001,121410130210200], + 1102002121232021: [100041001023101,103340440140221,110030000010100,100003024100303,102010100200312], + 1204001300004020: [111214100000104,102103034004032,100430221011100,102221410200012,110422010000200,103112021442033,110044014410012,110030231214100,111121012243322,110100144404220], + 121211140020242: [102210100313100,100004420014012,102240210240022,101040401032021,114200004110030,102024124011010,102000324013042,100030124212213,114210102320112,114234004112000], + 241440440000204: [100014100100001,102100004130301,102201101122100,100021424301033,102003004003400,103340410140122,100102114100420,103000121434032,114104012311322,102022100223142], + 124110012023230: [100030220100110,100002114314022,102000100200100,102020400244030,111004012200210,114402102312001,100413131013301,110001102103432,112033300230131,110102002011031], + 1113122102000210: [100222004320102,100110004103122,103020200141000,102414034040100,103031300144042,100120010421220,100000111034100,103132114002002,100412200002013,114312004002020], + 1000034443143001: [111301240010310,101300400310002,102400014040241,101120321040104,100303101000021,111001212232021,110002300420010,102202110230404,112004031112020,100240011003010], + 143010403220012: [103000140141214,102422021113012,114020204101200,101021321034010,100140014100401,110001120421122,100000101024224,100100030402102,101440000330201,111240142220304], + 101204220003242: [100313324320240,102002212000021,102013201320403,100001310421201,110000110021420,110100410011143,112000221133021,100130000010204,102443324020000,101134004004013], + 134202134322003: [100032141000004,102302221002020,111020112231430,110003222001121,110221222240310,110020401021000,102103234023110,100222420432002,112110002014431,111002024410131], + 1121200020230243: [101100230013304,102330420243012,114011024102042,114402212310021,102310100240232,114230200210013,101030320340141,100300004314400,110020312200022,111302222202200], + 1441010013200133: [110011000020032,111000044400210,110004204210030,102222021012222,100033304311024,112231212040100,110240142123020,110012322102010,101230004013020,110220212120101], + 1010200132121021: [114020010030200,100004402212111,120011211132142,110020041012320,103210010100241,110140430013022,111011202110211,111001430040243,112000014004304,111024204120312], + 1024411110244001: [100100411041000,112010012000201,103241131401223,100021221030421,102101101021304,100400120013011,102232024002401,102202000232032,102202141120400,103011001244001], + 1040424440410030: [114230000001013,100002031032111,100022211001110,110003214210201,112000002310000,103002000122134,100204224322300,112004000230002,100402222200122,100422000432002], + 221422402030000: [114201204111222,100104001041200,102012200202303,103222114034232,114122112202230,103221204032410,100004004102410,102301101004100,110432112111103,101104001101000], + 1412100222020022: [101301014221122,114220040000201,102102204022310,100404400013222,110012130410040,100104101200201,111040100020010,112201010203210,100000214310412,103042320101230], + 200233421020404: [114000000032100,100122124300010,100110034101010,110410224241010,111300402201232,111011100022010,100400444100202,101120101424040,101200111010033,112100404020132], + 240220300110300: [102102101412200,102403004020222,1000030331001004,411002200000033,101111220222002,110144110000000,114320100012003,1042001130040011,100424222031420,112140022310000], + 1104201022123041: [110421102023242,112100200230014,110011414201101,110001000023414,111440120030122,110202002231020,100120400400010,112104334041420,103043221414000,114400104140001], + 1142010011033222: [114020000030002,114031000022030,100201211003004,102014002000401,103103241421322,114121012340044,102000400240203,102104304023201,103310300140324,100002224244002], + 1023212020000302: [110222304210114,101003000321222,102011131320100,114020000023210,110034002002003,111100202242202,100321104310301,100012011020041,112440222014310,101023031030021], + 1002120030130000: [100300024310001,100012040401120,101001110343210,114000334010312,101022030300011,102214211122201,112300101130000,100000004100300,110004232203001,114400002323224], + 133100012102102: [110011032010001,101001131021120,100000224343122,112011010210200,102310030202020,110020101010020,102420201112010,100002110000403,100242104310100,101021200342003], + 1021010132024200: [112212320200423,100044011022224,102301011004011,102200111110200,102130001400000,102012100200021,112224304041202,102034010220333,111103044400100,100314021003440], + 100202121220013: [104103201240410,100300204010001,100011320043322,102204100232030,110110012110224,100200011220231,101004410311320,100200310110000,102002122014040,103112010212244], + 130024244021232: [100430014323000,112100021100243,100212101003134,103030014000020,100020024100324,101230011020020,112003002001002,102012201414304,114001404032310,114000200041240], + 103011221104400: [101044214042221,110024010120300,101122001110002,114102002340031,102200011300300,100122101200000,110114022122200,101442404002102,102200101102002,110200340000130], + 1000343224004101: [100400031010020,103442024002002,100320024212400,112003300212122], + 310140200012220: [103114001444241,111324002200000,100030211020221,102013110232000,103122340101040,102012114000000,100001214214401,112140422012414,101411100302340,130300134014230], + 1140002401203124: [140021043021204,103120420210322,102143020210410,110412000000011,112100214000031,103100004000304,101002014211041,110022002132302,110112402141330,100400302201014], + 1021233321020042: [110104221201402,111101302241011,100003000102230,100100134100314,114232230211044,101112314022000,101001104011010,101410020300220,101101241113422,101102201113101], + 104201002410004: [101042410301221,110432300102000,100011004102400,102304000210204,110040344210011,100020120101000,100003200020112,100400231000200,112143144020012,101000100340001], + 1011040102010244: [102021421100320,110441010032000,110000401222110,100020341221002,110410031002012,110330110101124,111010022200110,110003031232031,110032311222214,111302002203001], + 102201000400010: [110101231202300,100130444102110,100001204342232,114132202313300,110223310000311,103010304012101,102210044010110,112000404000001,112000001121002,103103124000111], + 1120210230240223: [102440001113120,114311204002010,110004221040341,103200204031212,100001024240030,100410110002020,114004102201202,101010014001032,100222014121024,100402002200000], + 131001110000200: [101230002122040,110100041200400,101210241204043,111311120014011,100123011004113,100420001002101,101134224001001,102321234111310,101004010323441,102000024000002], + 1022240011021003: [110203131211112,110021100023210,103122000100403,114103412201420,110014300041302,110020041310021,114241000002004,110020310022021,101121021020012,110321001330010], + 220404102401302: [102422114040010,101204400304011,114032424122040,102020004001311,100101101010100,100301020420101,114103212312012,102321044112101,102002202000000,100022024100041], + 101000002020402: [102203344011410,100021324100000,102103430210003,100012014300120,102414014022212,102012220241003,100032000101014,101430211012120,100204021000012,100032134101100], + 1000101040140100: [102022404012203,110210334214024,112020010222102,100100324232004,102141240210423,101410014024001,114100000212230,102100031320041,112141102011002,110020234201010], + 1120220203003222: [112113214020100,102010202004402,111130312211003,103224041400220,100001321032243,102104244000010,101001010300404,103340004020422,102410220200004,103113010102100], + 102102301442122: [110034012104202,102300444113103,110402002023040,102443120230311,100411031000011,100032111220130,114020130030141,102010014000110,110220004211001,101120214002100], + 100410004300121: [101220040300414,114410002324204,101003140301001,403111002011011,113210210400400,1140104002020100,1010000000034010,1304032042210300,103100001242220,1120100002011010], + 1000302211014221: [102101222000102,100113004302233,101000110324210,114221002303200,101022204002023,111201012201003,110200122222130,110140211201422,110123012044100,101002114213204], + 1044023000010101: [110013202003320,101031241000010,102120231343224,110030332100203,100314114322101,114404232310120,103100034001310,114002202210331,100031301020100,110111032140220], + 222022013141002: [114020000030002,100113220020101,114031000022030,102014002000401,103103241421322,114121012340044,102000400240203,102104304023201,103310300140324,100002224244002], + 202000201124400: [102123420200002,110201022020301,103322110110201,101212002120024,100033334311001,102122141343010,101002400300211,101014204002243,101001004010030,100400010010032], + 242201000220003: [111431110000042,100302141003012,102004441124110,103303201400021,100000301221024,101224322120022,114100200002120,101004120224442,110310020040401,110200010014000], + 1030200204000441: [144131233204044,120130001004000,101001131032132,110102030010210,110400010031401,102220211120002,114112002313010,114014010033321,101400104042212,1003022312322100], + 1424411400140110: [110224314430000,102203301123001,103100134001001,100000001030003,114030314123101,114020142302420,114442222312000,101001001030440,114031010001020,114000024014200], + 300104204121110: [110001332120300,110003000420200,110243234240200,110004014411012,112000120232022,102041220200010,100002320113100,112240200202201,110020321120011,102130000312121], + 140320333023422: [100010101030000,112020112300102,112002100233204,103202300102400,102442004024220,102032440200402,112400024011003,102012141440022,100420101011004,114030424122003], + 1120432412431011: [101020204002030,114203042330220,103102211440104,102111022001024,102102231400111,111101100021200,114023010024000,114000204101231,100000400412200,100002020101023], + 142410011140212: [114021004032120,112000104023000,102323234114200,102002200244011,102201014020311,103000304013020,100210021001204,102101022004020,100010304110000,112022020242001], + 112344400302043: [114421022321142,101000204010010,110433002111222,110202441103213,112002100212411,103011010100014,103420201210023,100120110002024,114032102210211,114202332300110], + 1010100200403041: [103443024000000,114112124140000,110044220021000,100231020112302,102101231341022,110122400401032,102440020200020,102001020222140,103122411441211,114102004002022], + 202124011001042: [110030002000422,100011004343022,110401140004202,110040002034100,102402330230011,110201434430102,102110334020204,103200001420012,112002002000344,102120020230022], + 122020010401214: [114021104120000], + 141330010000210: [102101211411000,112032040234431,110010232004000,101020004000000,101004310324302,100102224033421,100120040400011,100214044220201,100400110020244,110410002020200], + 100024000322202: [100041000411231,100010101030000,102140040210040,114110030002020,102010031444104,103202300102400,114103200002100,102410010201202,102202244040132,102211201122230], + 122022030000101: [112002110220340,102002220221002,114100234004010,100030410102000,112240334012440,102101010210022,100010031222001,110020200001031,103001114001210,100034021034000], + 1112113200012020: [100013200204000], + 1001201041120242: [102340101000014,102002240241140,111203032220113,110232222040304,112241010203003,102120010230014,112104004022110,103010101412020,114020110001011,101010330320400], + 123102103100020: [102304030220001,102141124004222,112042422001032,100134101022112,103310200110020,100020031030323,102140041342001,100001001032400,112100022010403,103100130100043], + 1011021143020413: [110121130100010,112000111110400,100140001011002,101000401120424,102001114002202,103132120120100,110400004243120,121202102031102,111100210412220,120000200000202], + 111410240120200: [111304340002030,110102000401214,100100111044040,103140014002031,102024102020000,102224241110003,112003020220120,100043024210301,102014001130100,114022100010000], + 1001000221331101: [101100011102402,103100214000130,100002020122000,100002244244011,103001031403201,114040410020022,110033020003012,110023100420044,122333020133040,102011024010121], + 323212001001010: [102001404012100,1010400230221020,102302200210010,102340120222440,111041202200140,111300400002313,111101040014040,100023014313010,114021040010311,114140004123122], + 1200212020220311: [102302214110044,103041014030230,110113122120330,102310101100011,111012312140331,110041202203140,100021404300231,101100020320003,112120200200410,110332242220220], + 1001030011212013: [110032211204214,110230102122422,110103101002440,112432104012111,110130240011301,102002101410044,102002104011330,102100000220121,110222131200214,102103411140402], + 103301202212100: [111423000022420,140102120200000,110400444243022,110131001002021,203201100012000,122001000320022,121104330112000], + 210001203342400: [110240301111040,111123014100000,114200000003241,103103404004112,100110120023012,101042044010040,112021014022022,112002322032030,101040401030013,111300002204430], + 1111023030001104: [110003410004022], + 232030011020243: [110103014401023,101143214201102,100001044310021,114030444102123,102024000201400,103244411400010,103301201400202,103010031401122,102000404011100,100133044234004], + 111002014410041: [103300344012201,100122200012014,100011200201400,100201104224131,100002100204114,102203001300000,102101004001020], + 100020020103001: [100402004300002,110020134410001,100300020142022,102043001021033,101210211022100,110421202110000,114100202200202,110004100002122,100100121010222,110100122010310], + 1000000043202304: [112132434020310,100000144104100,101040100302002,100013030100002,103340114022112,100310034310200,101014014000004,100100104102141,102111210230204,102200421003014], + 132100430000410: [102343230224321,114201104111034,102310140240012,100014204201000,111130210020000,100141101044100,102114022004023,101022121001000,102102201340311,101410201010030], + 141200013120120: [111102004100101,103122020213112,102140014001101,102000104012232,114122134140002,103012011434022,102101010202004,101001220303224,114400202310210,100042030201341], + 114120403000020: [101121211101004,101001304001101,103000110142041,102002112041034,112401144042000,112200124010030,110422010000000,100020024100400,101000102400130,101304320302121], + 124320101203003: [112021001121302,100020001001030,100100311010420,111100022114001,112202131104100,100102201220030,103000021220401], + 102013202343203: [110200201311102,110332000400401,102100044001000,101012340321223,100020011230014,100011314203014,112410030231014,103023201244020,114200020212020,100222420432042], + 1104242102104010: [100100030022201,103200010100022,101000121032422,110400300400024,110202101314010,101000201031210,100010230021121,110034400040011,102000221103012,111300040040303], + 1020300002112112: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,103022110142241,103012000100422,101002024000400], + 100004032134001: [100304201000221,100112021020320,103010001422020,102300124023122,114221004100020,102304100210334,100403210010142,112003100241220,100301104104210,102101004000001], + 1400202301000120: [110011414240022,111142010020301,102100104000040,100010044300003,114130210231020,112120224040040,103301410110110,112114324040000,102124031023100,100204104320231], + 1100001000200030: [114011302301400,102304034110400,100043010120010,102101124001310,102430300201034,100130001014110,112030122000001,100004121030301,101102104020404,101031001004201], + 1010020202012022: [101404110301130,102000001322140,110030411202403,102001104000101,103000200000240,104121003020042,112210200412300,102010020200000,111220034440403,122410423203002], + 1001401431202110: [110021031040112,112004030241132,110344041332022,110322102201011,114302300000331,100342131201000,114032402301302,101420010300301,100211244340000,101010334002200], + 1000001220030040: [100030204300220,101021334000222,114010122330030,100011024201101,111222442222413,110030122102303,103044001412002,102211124032000,110400200000240,110101301000001], + 1001404440121400: [100122004300410,112400202020003,102000224000011,101212040303123,100021021000101,102030200240232,100011124202310,100030300124130,100001100013110,112233332034000], + 114010004120201: [110000212101040,110021410020203,112024232302040,114013022304040,100040131021101,102322121000002,102021311100042,102030100221011,100201020140421,100004001002300], + 1004304022120141: [110100104404110,102110042001043,110200200400310,114100002204212,110000011301000,102000100220240,110013001200012,102341101101130,114010000033220,102100014000101], + 132022120032410: [100423004302232,100110034332223,101223100300200,100001130001003,102001034002201,101104401020410,102032031440302,100113004304010,111303214132004,100001000100200], + 102002000030000: [100104010021241,100004301021110,114101100211240,114102102344110,114010002300003,100112110020301,102022200223242,100000004102124,100022301000112,114121030220301], + 130010121410000: [100441200021020,102122041411241,100003000102230,100100134100314,114232230211044,101112314022000,110004331321320,110224102020200,112023024000400,102202240230002], + 100101022000030: [103030411422014,103043334040203,110422201312402,102120131401230,110200302024000,110210020104031,113130020101411,102041210224224,112200030203124,100130334030100], + 212110000000102: [111222202220021,111432124443120,103423201200020,110332111334020,111042000000020,110000001012000], + 1001401010120004: [102201124020122,110210010400143,100103034003113,101020301142101,100130120400120,112401030203302,110212000400101,112003420210300,112212022020100,103020021423140], + 120241321204001: [102010040210212,140230300211231,100030010000110], + 100331300001000: [110122120100022,111100424100021,110111121011004,103001020104102,110200422113400,112000000223310,100002214210110,100011200201230,111001002201034,112024144002202], + 100401000111100: [102304200241002,112144232304210,114401212321020,102011011133120,100001004130003,114013000011100,110102304220300,103204100112201,102102101410121,103242110100304], + 1400340212321013: [100002031120341,113020001020004,100003044210040,103243401401133,110012212132410,101210014200430,110014011320012,110400022122040,101111010020120,100223400002001], + 1020000322341344: [114011002300120,101221004042212,100303111000101,102011101321222,100010001023120,102002101120132,102010200213332,101100320320310,101000004211110,101230420300200], + 1142200423022124: [114033120034402,100023221022210,100040221211010,102104010311220,102230022023230,100014200003002,101122001110433,110320022024110], + 122241013202100: [102002014000220,100002011042020,102010200221000,101041201002422,114402320000202,112000002000420,102012401001012,114201224110141,112431004013030,114003002301122], + 1020042002200222: [114300304001000,110214110004122,112021020220112,110003020001402,102000401102000,103021000101321,112231202030221,110011102103221,110102400111401,101301000310233], + 200014210230001: [101221020040220,114022412330004,100103104302044,101041030320401,102141212000200,101203121020430,103130021444021,102100104002224,102020004000014,114144014122041], + 134200121024220: [102334004110232,110002002000100,103013000104404,112200102024122,103000034003300,101000100322140,100000040001141,110002001231100,114010010002314,114124002341030], + 1430001204234321: [110200100002031,101420310301020,111103224103001,103010301402112,100011401031000,100020034100101,100122214300222,102332100243030,110004424200024,103134021420204], + 102023043030212: [100422000031421,110302040102004,101402114042420,102220021120430,111341300012200,100102000010243,112410034040040,111302304130401,100024334203210,103031410122401], + 210200000200202: [101230114202200,100400000020230,114300124030100,100202031002101,112411140200242,100121114230123,102321014111202,102102334000400,114323400212122,110030110140100], + 120001200240102: [100310120141002,103000004002012,100002011042020,100301421002002,100202140000111,103022021431010,103200020111014,103104200210410,100240101000030,101003104212220], + 142000220213430: [100030010011002,101021301022041,100402300013130,104402130010100,140320413003120,101201220402420,400040001020004,1001120000022000,1323104441242212], + 1121200020110210: [1010130003011221,1331041104430100,200142102010231,1032220014300112,101301220341310], + 1140010130121200: [103000020120220,100004001020100,103030340110000,101420110330224,111023102200413,100110100000022,111424124422102,101030101022201,100022001231203,110020232200300], + 212034003213120: [111123010022304,112003001133011,100201134100140,110213002132000,102022420220121,111010132204402,102401214020202,112102204024002,100100424030003,101000131030120], + 1111400101000301: [110101231202300,100130444102110,100001204342232,114132202313300,110223310000311,103010304012101,102210044010110,112000404000001,112000001121002,103103124000111], + 1010140041312320: [102000004002101,101403014020203,100402004300002,100042030120422,112100000200031,110003032000041,100003200120040,103300234023033,100112000410320,114010340043300], + 101023332233040: [1302101004142102,1043303323011400,1002000010441103,1122204031101014,140011220320300,114200022340011,1140332400310103,214301004122000,1020002000321320,1003033202212100], + 1040043400404100: [110320202023400,111431110000042,100302141003012,102004441124110,103303201400021,114101420030202,114421242204443,100000301221024,101224322120022,110104422010121], + 1001104232404220: [102110230230004,102020034010140,103102010211110,100021000122000,112130002012100,112203420410100,100020404100041,102320204112104,101004210301301,101001100301030], + 1012020010022101: [100004211221210,114022042302201,103310101401010,103220030101023,401300041114001,112032302000220,112003000230001,102004301444000,111133030010200,102103231340304], + 200004120133002: [112120200204001,100030024301424,101011114210004,100024234202001,112102010201010,101211020302000,102102001342202,102420034022021,102130000221211,102013004023003], + 100001020423013: [100120221021011,111242212222022,102022411100012,100020100100300,100001210102104,101401140300101,103220200100320,101030004004303,114102404120000,114000020034200], + 1000131040022130: [114022412330004,100103104302044,101041030320401,101203121020430,100002004104004,103130021444021,102100104002224,102100224000210,102020004000014,102103321411004], + 1444010010040200: [114011220041204,100301031002201,100000224311320,102120121212031,112000400223100,102022031324020,100211111003420,101100004022130,100344041000232,103123314002423], + 120401221004200: [110141201302122,100023001222000,101002124002220,100101004230030,102103012004030,114034000012210,101044004000132,114114004140010,101010241113102,114030142200400], + 1100140342302400: [110104112010103,111102004100101,100122004300410,102202414041044,102140014001101,102000104012232,102021100220101,114443330001442,100230120001003,112042110220004], + 200024300000202: [114444244144110,102001200221011,114201004110120,100412114304000,103001020120202,101000020302400,102021014012210,102244221114031,112400000200011,111101400011011], + 124110421221040: [102100010233022,102120400212001,114313022302101,114021002302020,102313204114304,112100102300200,103001324000110,100002014200021,102300401001010,103212320212011], + 1100020010130000: [101044400340202,114101422201430,111014314400310,114020000010101,103121041440100,111130010032011,102012321321040,110020232132221,103203011404430,101012110312230], + 200323144411410: [101001421031220,112220322030220,110210301200101,111000034110311,110400241240242,102200001002100,114443304123123,102000024010002,102413100201310,111001102202224], + 1001142124010100: [102100304000010,102332320243001,102202014030001,114003040042312,110201400000100,110400204221003,112021324023000,100100340400000,103202011201000,111000000020410], + 234421004212212: [103011431401300,101302134233230,100002200103104,102040300241403,100431000032001,100013011020311,100202031002101,102103331400000,103013004020003,100120041020012], + 1030130231314220: [100411410430220,101410011012112,112300411132120,110131310000224,112104124022321,110100022012033,100221004340224,100103044230022,103222330131101,110020124201103], + 1440320203000011: [110400112011100,114420304140242,110441010002400,102300120242120,114203104001000,111210002244201,114000004102022,110001022130201,102430001113001,114212102310100], + 1140211300000040: [100030220100110,100002114314022,112030122000211,111130202220102,102000100200100,102020400244030,111004012200210,103112100101020,114402102312001,100413131013301], + 1022312240013142: [101001131032132,110340014422102,101022400300001,102140004000100,103202130122102,100021000010213,100231004220242,112430010114123,130020100202200,120002101133400], + 1003020300103014: [112012000220043,102414000203000,111101400022211,111320100000001,112002202000010,114001102301101,101010041003004,102000121442001,114011020020242,114030100040000], + 102402330013411: [110034300021014,101042401000112,114400112314022,103004104003011,114014010043112,100112440013034,110104140001020,102011114000320,100041001211002,114200134110042], + 1140112030002221: [101201111021101,103131044031101,110211100000033,100012010200202,120001020012001,102121042000004,114004312330002,114304304030022,114034424023412,100000220112324], + 1002030120203312: [103041220111410,101100202130022,102004201032002,111001212200200,114101012343012], + 1424403001321040: [101000201232022,103204024030020,112200011102023,111430004410400,110400304211041,112400040204203,101020304214000,101101011201302,114100000210113,103422044042141], + 102030010002014: [101224001202324,100002001024100,102103130221330,102011310202304,110010311210011,102022421132024,100002121021022,102001331441012,100203014121400,101400201102014], + 221212002022030: [101012131000024,102120221022200,114221104114000,100001111032112,100400212200322,112400004020421,100120120112100,103221021412001], + 1020010314001321: [112004302004223,100011030420233,100000014100111,110112001300220,111024132204021,100400032200141], + 240312210011031: [100004401212000,102123242001200,114120320224032,100000311022110,100202004324201,102041020200401,114030012303012,101003131110001,100000001232300,100240130000020], + 101000400012240: [100400142200030,114020020001014,100001144201220,102120304001402,111212204101240,103210031410020,102330044110040,104103022103210,114400130000014,110232012044212], + 240003400214010: [100024000110221,101301014221122,102102204022310,114130014001202,110010220103020,111004100022110,114040210022000,100404400013222,111001344400222,111000000000411], + 1000130000200201: [1010400230221020,111320012221132,102302144110440,111101040014040,114140004123122,102143202000400,111020002202333,101321311004010,102110241342210,114122302311011], + 1041200221400003: [100030040101021,114310102300021,102400124020001,100102224234101,102010321411140,102111131410342,100031120413224,101304004220404,114104214003030,114004004100210], + 140224000241010: [103324221401420,110400332010004,103111004004332,112204340204032,101020320320424,110324011300003,100014121020424,114300034032400,110313010000400,111002022220000], + 320410000002201: [103212014020132,102102030214401,102021420233130,111130410020021,101022000302211,101232020300432,100044004210004,114020204024101,101031320320042,100102101000203], + 120122100110241: [110401004221204,111112000011222,100322444314002,101003301020022,100001030100030,112012004004000,112044204000441,103141100104002,104110100014103,110341300400201], + 124022102000302: [110102401201204,103020200141000,102400100230000,102414034040100,100212030414010,100412200002013,114312004002020,101200020303202,102020041321410,111340300010010], + 1102422243013103: [102304034110400,100043010120010,102101124001310,102430300201034,102143432000102,101031001004201,102040010200101,102200434012013,100021301302122,114001110033210], + 101404002000100: [102121240200000,101212040303123,100001100013110,102402000204104,114024142200303,102010042000041,100011221032200,112401042010001,103223200110112,102031021133300], + 1141322000013000: [103140211443110,100030001020201,100242141004122,101302401003202,100012200201130,100004004102002,112020201120340,102300001002140,100204220000112,103210200100000], + 1102404301201104: [102101141340120,110123114221102], + 1004340442022302: [110300010040010,100001044200004,114121222313401,101201020300000,102011201441000,102100112002212,114202200002400,100113410410314,112230004011202,100131124002410], + 124200240100040: [103201411402002,110022000023010,103101224000011,114020302300110,111002100021022,102200042000104,103002000104400,114100032320203,103002144042123,110114021000012], + 101120402102000: [111202114103220,103000121421121,114404302200120,110140011300020,303320304020413,111020012233400,1000313001212002,110013024421020,110001002010000,101043021021030], + 200101434110224: [111100224102032,100102244032220,111100214402203,102310310210000,114201124000012,112104124041104,112043222001113,103412024004004,102041011123103,110011301033002], + 130411300102120: [111120230020122,114301000000002,112124310203104,100113324103000,102001000221124,102023021321020,114040204014042,100040401020413,112414334044310,114001010044120], + 1402020002003022: [103100030100010,100003414100400,101023221000031,114221004002212,112010022302321,101000214211011,102300131102000,100110204101020,100000001020034,111322242223400], + 100401002000040: [104230032202131,103021014043200,101001024040001,114111300210304,110022002010132,100220210000034,114000212212000,110012112002100,103242100130004,103022004011103], + 220012021000000: [110010000020000,100400200022410,100110201000134,114233330000221,102322011000003,102123304002000,112000004002402,102010224000100,100040340003012,100043004310410], + 100011024113021: [111003204111140,110200421002003,102101142002021,100403304320200,110200024432011,212240000101000,100210020430111,102110211120323,100233031002400,100310014101030], + 320401200021010: [112112402304310,112200122022200,114430104142400,100011040420210,111022002200300,100002000120011,110003042002123,101104004000220,101000120303002,101300240310433], + 201423042210004: [110013202003320,101031241000010,102120231343224,110030332100203,100314114322101,114404232310120,103100034001310,114002202210331,100031301020100,110111032140220], + 1423003010401040: [110141010001110,104122011242020,110213401202210,111103310001234,100110441001000,102312000240002,102012104010301,114123014001020,100004004303030,102001424000000], + 132001001231014: [102302340241312,100410410002011,110133000404002,102101224002210,112104230200100,110311232120010,122203322100011,114141142204022,102010010220014,110330022021224], + 1004030020020100: [110202000002301,100021401041100,114020000011320,114002204011413,102010111411204,103040020122222,100031001030010,103433144040432,102310201001420,102420321400201], + 200340004100220: [100032041021210,110004301222000,102040011121100,114310000001232,111322234130000,110104002010100,103100104000121,110024140142000,114304422323310,100212204243022], + 320023042101041: [101210320301302,100440024301100,100114104101001,101023221000031,101400014040400,102012034000402,102100122002001,101000011021414,114101000221221,114010214101003], + 1010104303302014: [114020000011320,111020032203301,100031001030010,101000210303342,103433144040432,112100034020100,112102204020000,102021104012002,101440400302320,103000121424330], + 320201430112001: [102220011110041,102144032001002,101004344002124,102402030203003,103022011400040,102011011133120,114411400000121,114023240040131,114310024002102,110423300004001], + 1024112110330043: [102000001132113,102202310203222,100042001020203,102002320220202,100010044300003,114130210231020,111321314133000,100004410120102,111222214101043,114412142320040], + 123320213104000: [104100002100221,101200011020000,112000044002102,111300220000230,114110032343001,102230021122000,100031224102002,431300131230002,102001024011010,100010004130413], + 101210010120004: [101444024041143,114121002310100,110000010033022,100001101023021,110200332041001,102020032000000,102140101342121,102023214001142,114002004033124,121012301123040], + 122400302230121: [101220040300414,114410002324204,403111002011011,1140104002020100,104402130010100,103100001242220,101201220402420,1040212001001234,1001120000022000], + 1011133000312204: [110111111010000,100001114111300,114120014004003,110300021330100,110131311200401,112400114041020,100100441000034,110242140012303,101030004000120,110441222110003], + 1403244101212021: [102440011414040,102010244010004,102031004010230,114121002310033,102122014003000,100020004100000,100211001000020,110201222031001,111101202241011,112302311103001], + 212111014111300: [110000411313130,110400000001201,110000010430211,110001212130303,111403414421302,101221311022241,110100231202400,110020102102000,100000201022030,100402021012201], + 200042300340212: [102133011413110,111001200041102,114022424102243,101223020300040,102034324000220,102022400203211,101230020303000,111340130010314,110200422121211,101214240300041], + 1003002200122031: [100413311002132,112220322030220,110210301200101,110400241240242,110023102103200,102400140230123,102112300222001,102000024010002,103302020111204,114113020221100], + 1023040031411001: [114001210033034,100012200002000,102000141104022,111221102222020,102102010211012,100230220410213,110210002100320,102100220220023,101111211012031,101213110301020], + 1100211204102022: [110213100122010,101212101023221,110213001300231,112120222020002,102130100222100,110200204432001,102020411123201,103024041421002,102200034042002,102030004010204], + 200041001110112: [102242320200020,140203123020300,102101244022242,102010011011210,102013131134030,103312010110013,102004004010011,114101042313041,122112024242100,141000201412111], + 201200000121142: [102021001132040,102301004110004,110402420402001,110021021210300,110404000000012,102000101120123,110221022101104,100020311220412,110123004401121,102203031121210], + 112120004022400: [110011414240022,111142010020301,100000144104100,112114324040000,102124031023100,100204104320231,114002104020100,101032001032200,103132004002020,102001204001021], + 1122002100013102: [110130432010223,101023312403223,100421310020001,111220012220010,111102302241002,110200002132202,112441000200100,114100040223000,103020000002031,101144124202103], + 1000100122031223: [111210000001101,114013400011030,101201104040034,101020111030400,103004104010210,100202200003011,103210210100210,101013101033100,102204204042220,110100301000100], + 1010020431322121: [100000201020000,102030024112031,102401011401222,100002002212000,102114341341012,111420200002021,111001224121320,104042022102100,104030002100140,103421124042304], + 300000003200320: [102210011101414,102110201342300,102102011401410,114032124013234,102143020230411,101340141003001,101210100300100,101014424010103,100102014301210,102043024010103], + 130114241002003: [114213004100220,100241210430100,101220301021003,110032424422200,100231411001200,102014031102230,100130044231012,100000230400204,101210014040333,114411330004112], + 100120010200012: [102432004021410,102111120200030], + 210112341303120: [110400022010030,100214121000000,100042034200032,102011041100210,101400240300010,110002131200133,102412241111002,100424104302020,101013234000010,101122420322200], + 100003310020001: [102334004110232,110002002000100,103013000104404,112200102024122,103000034003300,102011000200113,101000100322140,100000040001141,110002001231100,114010010002314], + 222124002003130: [103202004001120,100120204003012,1300022002310414], + 130343014011100: [114101024120020,102004011440212,103140320213200,100000001021013,100011204300012,114003134011032,100101234330123,110024000432310,102012101443110,110032220022103], + 1002110232010033: [111102440020002,101202001024340,103312010113222,110130022140122,112002304004203,100034110413403,101030040320021,102123411402002,110100042013221,101042201030422], + 1120112042000122: [100220034323210,112121212300101,100001124102222,100400100022003,114420002322000,101200034044300,102204044042410,100020310010001,102220001112023,114302014032021], + 112211200402101: [111220204101421,110042120021013,101001010300011,114012020044224,102122401340101,110021020001220,110112030401012,111112204404021,113030210140400,100030120004242], + 1002140220101040: [110411104220124,114210412314301,110112202140320,110041024412043,114410302313304,100144320410201,114442002310100,101101001100002,103102121242202,112024402004000], + 103120100230203: [100034244210020,102012004000003,100411000030110,100041014210020,102041201121230,100000030100102,101012400320002,100002131000002,101001244010120,102041104001132], + 121001031130240: [100003211020020,111000240044102,100000101040120,102300000220000,102323320240010,100011200100023,100010044213301,100330204322010,102111211401000,100122124300402], + 1101000200000322: [112213102031413,100340311000202,103100011242104,110001044200212,102102000202442,101100301110000,110122022042030,100220201000000,101010000300401,112012022340101], + 104123333420233: [110013112004021,100100004100200,101021404000220,103120140210020,102143211343014,100112000410320,103002110114402,102012242000404,102100214000001,102012100200002], + 201201211000231: [111030212113431,102001111011201,103222004032000,110044320441241,102233034000002,110410122010102,110123011200000,101122404022022,110311110410340,100100200021431], + 1034100301040004: [112004210244200,110210010400143,101200400303422,112024424001400,102100220202200,101020301142101,112032142000000,102102044002304,112003420210300,102100321123023], + 1103322102400200: [110121100004131,102000301101102,111122200021102,114032234033303,110102022000200,102200034040443,102323004020100,103114211441300,112431104040041,100110204300200], + 1032000000001432: [114031022302044,102031011441221,102021201410011,114103020221100,102002024000132,114430412322343,102400004021004,102240021302000,103202140103403], + 1002103400401013: [111121100010021,110310034424102,100100010422000,100024201030210,110100001014311,110043400012000,102120400200312,102122134021133,110030401311204,100013014100101], + 101120210201211: [101020024001041,100200201000001,100422211004214,102100000210002,102121010210004,114013214010111,112224232044014,100010004210020,112002100240200,100001404100110], + 1413223440100023: [100310444310004,100211001204102,112333412022030,101411021100200,114303202300104,100210304340400,112020044000400,103230004000322,111201314412204,102100300233312], + 111412024243241: [100402230013203,112132400200233,102030441134200,102103024000200,101032041032203,100221114231001,101222024011320,100021304310000,100400022201011,100010004313023], + 100034304104031: [110112102211042,114314300012000,114200022300033,101400220303133,110431442110400,100100111041320,101420010300310,110000004210112,102334001004100,104100001240034], + 100000301314232: [111130312211003,103224041400220,111103240020200,110022201100020,100141214304000,101430001012430,100011204100020,101001010300404,102410220200004,102100211340043], + 312300424003002: [100010400013202,101001201110100,100113201011032,102230000204000,102003134000001,112010420232040,100001324201100,101440004041103,110240220012030,100220410101001], + 1002010331200340: [111100114401014,110003112130100,103000230120042,100101141042243,102001221100211,103222010114132,101240204233201,100110004332200,100403211014030,102001004041400], + 1030121204003023: [104120011242011,101230114202200,114300000000002,100400000020230,114100124002210,102432044043002,114300124030100,102211020204231,112011204004112,100003000002034], + 113040023020204: [110002130002020,110112040101001,100031201033102,110004031320244,100211204030111,102111001023033,100212204221011,100024001042210,100120101042400,112130024024102], + 122322100020401: [112211122030420,101031201001231,102000010202042,102020001100001,102020324002022,112013012301132,102001104001214,111004410022000,102221241110321,124301340333312], + 104022213410100: [101000024010001,111101222101212,102001310224010,114000224102000,100112034103110,102000104012012,110101101241222,103021001412410,111200200000421,111024104121140], + 1040120000401000: [102103222002012,102010011411233,114004322320200,100403220020024,103102100122414,100121034230014,114322002322044,112040200210223,100002414310100,102042414010212], + 1404230111101211: [102013024000211,114021004011100,102140140310001,100402022200102,111010302203001,114144212340021,102110111023103,102302104112440,114100102341011,113112341020242], + 1000002000400321: [100024000110221,114130014001202,110010220103020,111004100022110,111001344400222,101021204010011,100404410022320,103012101410102,111000000000411,102131304003000], + 1030120121200302: [114012304010103,102211034013100,101232404040100,100044000201201,103320304021024,100010214313120,112040022002231,114401322310000,101110404001000,100000000101012], + 100200200340202: [110010220040411,103100104000230,100303021002102,100010020101220,100310301002002,100021201031200,101221001202021,100301000142122,102101301342021,102324204022104], + 213102140031231: [101010001000031,100021020104221,111120024101141,103201214021013,100030220410304,100011034302423,114200144110020,102142002000002,114120424122030,102104432003102], + 112100003040201: [110201012032242,102011001134111,114102034001211,102302011002003,100314111000314,102311011001213,103222004034100,112401420204002,102002101100313,100000211001010], + 130120034003120: [114240324110412,110020000140010,110200012030221,110212010000420,110000001102000,112002002034420,100000014340041,100010300404300,110204321003100,101212210303021], + 120000142320021: [103122020213112,114101100211240,114122134140002,103012011434022,101032010342004,114102102344110,114010002300003,100112110020301,100000004102124,100022301000112], + 1010111422021134: [110410000104042,100014014203233,111422100034314,100000040413000,102030414003000,121310232003222,141000013100220,100220021000033,102112104004041,101020041110132], + 130400102000042: [102041310200042,101000304014100,110301030010140,104100002101431,110221000111302,110100222001100,101010001002000,102030020224102,111330020002213,102011440201423], + 104110011124210: [101122001110002,114102002340031,102200011300300,100122101200000,110114022122200,102020020224002,111302004133300,110200340000130,110100040100302,114101040212102], + 1021022200102142: [102422110202040,102304030220404,114004200041442,103000101432004,110200402121012,100301111002101,100022000101100,112010042000010,102020001120230,100310011002143], + 1000404220210002: [104010100010424,103010014013304,102103030201001,100010221031023,100140000024021,101223024200014,112240404012020,101201024203004,104000021220030,112042430240120], + 343003000320410: [110013312204132], + 221202030120330: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 1014114220020004: [100310120141002,103214010102022,102324014112020,102404021403141,103022021431010,103200020111014,100010004313001,103104200210410,100122020011232,100002200410030], + 1102000313013301: [110441234224400,114021412213020,110030002000422,103100014031411,110000300424304,100032121024110,110013122130200,111403100030130,114020204102020,102402330230011], + 1202430201011220: [110400011311001,103300120141130,102110004000221,111144202220301,114224204100310,101434031010012,102304011004310,103101410212231,102100144001112,102000041441002], + 121424241101130: [110044320441241,110410122010102,101122404022022,110311110410340,102300104110220,114201122320100,102303014110142,101442104021041,103020040104002,112021000221430], + 1002221400234232: [110204400000120,100000121020303,103122114004113,100200020431202,101344140314114,110020004203240,112001202031004,102110001141443,100020010420242,110001040133002], + 300001012000400: [102020100211004,101023000340120,102241210201000,101012400320002,100002131000002,114040222301101,102140110210424,101201000300222,101002020342202,112004044022023], + 1402010301022130: [110000000003200,111401200000040,102300122004231,101041204222101,100024024211001,102110001342114,114342044032200,102330311004110,114032110040320,111203012221030], + 1111040034440220: [102340221000300,101000130320340,100110020031042,100220124221000,100402002201002,101011014002032,101002201140040,100211000412142,101010010320010,100141021004020], + 1133024112120201: [101232314010241,100301300121100,103020124010320,100021300101201,110230022122031,101000444214021,112102112301130,100414004300100,112102232300222,102200000201120], + 1004122020334002: [102120010200131,102044104002014,100000204214001,102022000220004,103001220104301,100102434300310,102004004004200,100421200001003,114024200040223,112010004020300], + 1022122220000220: [112401024044240,101222121020001,102000230223303,101004020340241,102012201412022,102101021341021,102143112001423,100003211021332,103202034020000,103002144021100], + 120422002400140: [103020401400041,102020111124232,110042042002231,100100031020131,101000321141220,100141034102022,103000204000002,100030041031020,100403110013000,100400230013130], + 1040020000442222: [112010121120420,101401014022004,101204011000210,103000001240214,111104040020043,114132404003001,102001000200101,101102001111120,100114210414111,101010104000142], + 1041002420020314: [100301300140011,102022420220121,100030031220122,103210000102210,100001301214030,111140000012120,110010201320213,110103010011301,101010404001431,103012204004212], + 124004200104402: [112030004004130,101340041000104,100000034301140,102111011142022,110211130002000,101420000330441,101040111003030,114022102300021,100023104101112,110140342044321], + 1010204014240103: [100001020120010,100103030001121], + 1432421112203400: [102114340204022,101000011030111,1303043020124234,1142022100220102,111143400421100,1212333103010100,4002031124040120,1001002042020200], + 121132013002022: [100040014331413,110130104401101,102040044001211,110044200021204,100220301003101,110004402010202,100023234240221,101410100302222,102130204000301,102111000210000], + 124100110113300: [101020024212042,100041204212120,102113110210240,112423424042102,100320431000002,411200101402221,100120214230002,102440100200000,103204200103440,100210004104001], + 113001000112022: [114430202311020,110302140014102,110431341000014,100342121000040,114411202310423,103021121400104,100020041044202,100011041020300,102140004000231,114021102303340], + 101102130002210: [110021000410432,103202000110102,102020440220202,101010010320112,100042000000000,112000021122010,100021111043012,102122101023020,110124041140000,100010044101002], + 204030401130004: [102230040200031,110122001010214,102023301102400,100030414300112,114043140010022,104120110010402,111010214402000,110303104423010,102000324040402,100100401040001], + 1102240210123102: [100021200124422,100022211042104,114020132303131,102020014002022,110022120020002,100300421002040,102040004010020,110004021102300,100400322200003,100002000002212], + 114122013002030: [101230114202200,100400000020230,114300124030100,100202031002101,112411140200242,100121114230123,102321014111202,110020004204120,102102334000400,102412001111203], + 323204032022014: [100140201011204,101203104200224,112010030221031,100140000024021,101223024200014,112240404012020,110110210012111,112122004020414,102000220204011,101201024203004], + 123210000212012: [100120011004032,101100400333023,100303111202002,101003201030041,112314322001102,100421320432102], + 210111302310000: [112224111100141,100040134340044,103043334040203,110422201312402,102120131401230,110302011332024,110200302024000,110210020104031,102041210224224,110240411110010], + 114000220112010: [114101020033111,112202212040211,103020004000410,110004022101020,110142301120031,102032001030043,114211224002144,102001441133310,100202424301111,102020001321030], + 1010004402301311: [103130424000200,114010204012441,114000240030002,114002322300200,103244034020020,103201034020234,114013402304000,114043342241044,102240101123140,112002122000310], + 1004010101034400: [110213100122010,101212101023221,110213001300231,112120222020002,102130100222100,110200204432001,102020411123201,103024041421002,102030004010204,100104011041221], + 1122231242203212: [100220210034042,101210004011003,101230044012202,114000012334010,114302200002200,110010204412200,114412402323000,103021304001000,100014041020302,103023001420101], + 1120004030200000: [114113104123200,101210210300031,110002021121023,102300040221403,102201100200430,100114021040000,100021020412110,103110000223000,103000210120000,100014001041210], + 1440001443102401: [101302134233230,100000130010033,114102224000201,100022021041122,100020001042002,100013011020311,102103331400000,100120041020012,100020001041231,102012204000242], + 1002020201230240: [100000131032010,102300011004200,101010001030220,100012200101131,110032302102400,100140204233112,101042141032030,111020134112040,103403044001110,111012020040441], + 1104432224020024: [110000001324024,103100314001030,101020111001331,100040301042132,101000001111200,114010040023411,102300404024300,102110001342011,100402120030401,102001010222103], + 201141101111313: [102110000203003,101010234004042,114002010040032,100400012201120,110311011330111,101204014010434,102020022000021,102000114010020,102102000312101,100220204342200], + 114440004442103: [100410231010401,100020104312003,103101000124210,101421104043100,114110000002020,100410124304100,120111111221111,100040400100302,112240222024012,101010101140202], + 1044124201010001: [114311022304002,110421002110220,103020101244010,101300010310004,100123100000010,110301130112204,102111004000012,101031001020222,101020014002021,112111104043211], + 1044120100040200: [103340041403223,112002110220340,102002220221002,114100234004010,100030410102000,112240334012440,100000221020014,102101010210022,102003224000022,100010031222001], + 1202110101013440: [100121230031032,112000431120410,100122200012014,102120400212001,103042024040104,102304104110001,100104211044110,114241222321321,114313022302101,114021002302020], + 310001101000412: [112224111100141,103030411422014,103043334040203,110422201312402,102120131401230,110302011332024,110200302024000,110021340020022,110210020104031,113130020101411], + 1111000400112004: [101004201002001,103112010213010,112200410200142,101212000301013,111400002102112,100034100124302,1320102201231021,100000211020034,100000040413022,101000000323000], + 1021303301042404: [100002201031130,102003104011100,110011024414011,100011104344414,103300204014142,114203022320321,411231400122100,114201130210110,104103100010141,111101222240010], + 1030212041030224: [110100034204020,114030020020301,110000030020101,110402040103431,101220011020043,101410101102110,101000040321140,114233210000102,114403334142212,112424004044002], + 1104430130322133: [114413100031332,102101001412002,100210000032130,214000110100040,103031420121210,112114222301010,110133330100020,100001001203011,102210220202130,102200120234012], + 122133411003003: [110010020020011,103141100120000,101200400303000,112314202020400,112400002013000,112314212000021,100010210000422,114310424030011,102000214004031,101001134014021], + 302002120320231: [103130021444021,101400004022210,102031021441200,102300031004340,102312301104422,101200020303202,100000411002023,102303200241200,102140202001100,100022200121301], + 122410120011244: [100010021034321,100031004101422,112013012301132,102001104001214,112100140200020,114214220001140,103144001420031,114024104100321,130040244231421,114311002324012], + 1100130002121102: [112213000200301,100003224334120,110202120003032,102410434000220,110110440020002,110202022102130,100001304103100,103340300113103,111121014422331,110210102122100], + 1400204220112410: [100221424320111,100203104322011,100021101021200,103240321400010,102010134012140,101204211020322,111102002240013,100011411040002,101002114000002,114010000020004], + 1041022020031240: [100031034311401,102000200200301,100104211044110,110200101200402,114241222321321,114013124030022,114104200220022,100034124101023,100022001221001,111010024402022], + 100140112230042: [110320202023400,111431110000042,100302141003012,102004441124110,103303201400021,114421242204443,100000301221024,101224322120022,110104422010121,114100200002120], + 102020100011102: [100000241020300,110000100022040,111021030042411,100302420120212,110131011000142,100201134320102,110000302122001,103302031401001,110202012020000,110043414212400], + 1011020220440242: [102400340230442,102100244130003,101000400320004,103220004020002,110320024422220,110003011010210,110220231211201,111211232220002,114123134000320,101000110323132], + 133220000001222: [101011321003202,114200204000420,102000031133000,102101401342211,112300210210310,100122300411032,110044121211040,100410130034202,100112004034240,101023244041002], + 100123004300302: [102101211411000,110010232004000,100102224033421,100400110020244,102021001411110,110041102012100,114222010213042,100022014302423,114011120010030,102310100243242], + 121211100240203: [114004142244000,102002004012310,110000011220204,111200024102040,101330120302103,102111301402121,100021204341100,102331011001020,103002104011000,101210041020340], + 101310240040224: [101042410301221,100102024100020,110040344210011,100003320401100,112143144020012,103033044023040,103231224012042,101000001001104,100110121040003,114211410004214], + 1104010440011401: [110000002100440,111214100000104,100430221011100,110422010000200,103112021442033,110213401202110,100400440012042,110044014410012,110030231214100,111121012243322], + 210140211040201: [110002004410202,112041002002124,140343100002103,100001424102041,111432124414000,410423004242042,100001222200102,102000004002001,100400422200410,112410122010012], + 240120313012101: [102400040202040,100102011010403,103121420214211,101022344001121,101314041002010,103222014000001,103000121400401,110000221104000,111210022244041,114000010012010], + 100032012041130: [110120144200000,114022412330004,101200221022044,110241112020204,100002004104004,102100224000210,114201104111034,102310140240012,100014204201000,102103321411004], + 101202230003021: [104132340011314,102203304123030,114012040020310,103132004002242,110000212104130,110200200004002,114131040224332,100123020032031,121002023311103,100021124203441], + 202204101440400: [100341320422234,110020422002214,110110132041402,111010430000202,101040214002020,101404114023200,111022124400200,112034310220200,113200210100211], + 1000011102304301: [110100200030100,111300030012334,110012000141104,140300020110000,100003301030120,110132020031210,100101004230030,103044004034040,102300231000210,102412140201410], + 224003030221012: [100001104314010,114441040000300,114003044024423,102311422001002,110022000421200,101132021101004,103314000101210,100110000031033,101210104011000,111111024101000], + 1000200020020031: [112312122020210,110332000010101,110022331320122,110000030132210,114002004103231,100001004311313,101403030300132,102321021102143,103123204002120,101010011001214], + 212000120431123: [110003000042343,100020341001100,102304000241010,110011000043131,114102400001020,110220201301140,102414424041004,100022221044012,110312300010200,103214210103210], + 1001302000231100: [100414204320344,100002314210021,114220102332012,102310001001001,101011431002033,101322204220222,100010101021044,102040214004110,100012201040023,100420311002420], + 1102212004214200: [110020001310000,110214024430312,100011014100041,100310201003000,110412121110214,100212341003212,110142300120000,112013212032000,112010220224003,112001040231401], + 101100134000304: [102314220240000,114210034112304,100014201221340,100400000013012,100044240002100,110122200000100,110313204431110,110211042120021,111210200002411,102302210211000], + 130033304044002: [103111001422000,111244302220204,100042100102211,102110030200120,100202140000111,101114000332010,112112211102024,114001032300011,100142044103021,101100010012423], + 111004020241333: [111030212113431,110001030120020,102001111011201,103222004032000,110044320441241,102233034000002,112130004021000,110311110410340,100100200021431,112101202012010], + 111040010211310: [103024420121003], + 1002300013001013: [100222004320102,100110004103122,103020200141000,102414034040100,100022304302043,103031300144042,100000111034100,103132114002002,100412200002013,114312004002020], + 1022020000021003: [111220204101421,110042120021013,112200420200200,101001010300011,114012020044224,102122401340101,110021020001220,112001024000200,110112030401012,112020012002031], + 100200010401011: [100040014331413,100213020430224,110130104401101,102040044001211,101001004001001,110004402010202,102130204000301,102200210202001,112402204042100,102111000210000], + 1122100000040100: [103100030100010,114034220041220,100042000102010,102013000202010,100200001210240,112010022302321,103204101402321,114233034103301,100110204101020,100004321032032], + 101010000102100: [100000020004101,110130014400011,110011232100412,100220040142222,110232002101410,110200021210212,110131021240303,103100101442233,100000031220100,111010000021300], + 1123110410210020: [102310000222133,100101220021240,102220011122100,112013032002214,101404441100012,112123102010143,102130201140012,112422320200210,112100211100021,100021300412024], + 1102110012000103: [102401030231212,114020012211143,100014011034234,100002110100031,100230112110132,114220414000323,100110404103132,102100010232001,100000324303120,102433214043112], + 221220202002000: [103100314001030,111201000013222,100402120030401,103300024014002,114211202324143,101203211010000,101200314040213,101021104212100,102100022002102,103031000121000], + 102012020210411: [103232014032341,103000001402120,101022000320120,111140130020034,132202044122440,100100104032130,111300224132411,100020314304002,101424324042012,102100004001040], + 1000120104010320: [110101124221101,101421000301032,102121122000024,102301004113010,101004004003140,112020300223020,114020014100200,110002002104100,102222102020220,101300201001121], + 1110200001311430: [101200001021021,114100210002204,100202421000201,111011022203204,100040204101003,103102014030320,110104110101023,100410024302300,100302001000220,103210031422000], + 112410003021011: [111002100000102,114021010040140,114222302321101,102101024002121,110014024202014,110220130100010,100020011030330,102404221402210,110203022032320,101222014230110], + 124000000130411: [100001004330113,100311304010012,101104300320030,101120101101310,101000100343012,100103404234443,102020010244020,111013104440122,102202130204021,110000142132013], + 100333140040342: [102120140212001,114400210002021,103103221421013,102010002000402,100240011000013,114233112330324,114213004000003,100044001020100,100000300410101,102034011441041], + 1021400101210102: [100400002201113,102420424042020,100010001032223,102111024000402,114321002320001,102001011100100,114402104142102,102122412001012,102311120222404,114020404020132], + 120100010220201: [102142221342202,102001200221011,102420000202033,101012400343401,100020101020404,100002411021201,102110010210330,100012020410400,111111102240001,102122111402420], + 110000010300212: [110120100120032,114010140023413,102003201410111,103222004000111,102431204040221,101221001021011,100301100420002,100040200001201,112000000210003,100000211231010], + 1103321010030130: [100023101001004,102001014013004,103210210100210,101043004211000,102120230212201,100014200010022,102120011340024,101004204210100,114031424101013,100002121021340], + 121221324324222: [103021220104200,100021020104220,102120001343001,114202332330220,112000210211020,100010324210003,103043011400000,114100210002313,100022124101240,102300200210240], + 114022020222200: [100032041021210,110001041213031,101110044200100,110414300030001,100030020011022,111202012222402,102000221442214,102040041320010,102402104022000,103203401400132], + 100122314120030: [114201402332241,114211030021301,210412232040000,114030214020000,102230104030012,103011101400213,112000102000100,121120101242321,144201000012040,112030040224030], + 102034021220430: [103134014000340,104103100010141,111101222240010,100040210411102,100110004102034,102040140220220,114010400014304,114300132321233,110000140032001,102033340222200], + 221010011014302: [100121230031032,100122200012014,102120400212001,100104211044110,114241222321321,114313022302101,114021002302020,102313204114304,100013200100011,112100102300200], + 1044102440002010: [100032041021210,110004301222000,102040011121100,114310000001232,111202012222402,111322234130000,102040041320010,103203401400132,103142111441040,110104002010100], + 1042010202200013: [102342214020012,100214104301120,102421004041011,103000404000100,100040004331010,101203001022300,102320234112041,112420030202242,110012021200100,100000220000004], + 101330021401231: [100002100412200,103200000101100,114200002331000,101012220324031,103042004010003,103320424022421,110410412110241,114203134112000,114220034000000,102133020200241], + 104122144011423: [101023101033021,103020134004314,110242410001011,110131211140311,102202100240010,110000121220010,100400130020302,111220340010010,114000004020044,114200022320103], + 104021022122200: [102420302023011,101100401113220,101402004040110,114220402322030,100000010402211,104303003022324,100210213323004,110221320110211,100402032000143,100404020040102], + 1102101004130301: [110310404422210,111030222201023,111001200003214,111230322242002,101220034202221,102200010204000,100031000413030,100130241010201,102010000203220,103024031430001], + 1100200032242224: [110141201302122,100000411231000,100023001222000,103140021211010,101002124002220,100101004230030,102103012004030,114034000012210,101044004000132,114114004140010], + 1030200004002214: [110200004243223,100000021030000,101000204001222,100033400410104,114102302311130,100413300430300,110020122000000,103144401421000,102240001100210,102120204022100], + 1031240121020103: [100042320001030,110024001010110,100100014300230,102043104010014,100001004300242,111120044100110,102200201110443,114240314000100,101002411030000,102002324011002], + 120103201012310: [114032104100141,101213114040141,102210101002412,111140100011101,103220120212134,112001144002010,111103314101000,100012011022000,114140104122430,102021241324040], + 1040000003000010: [100002044211310,102320221000230,112102200200001,1300001101120141,242022202122014,100001000100000,103014004000240,101141224002302,103430000133134,111043124112002], + 120010104011202: [110102042010220,101020124000413,111210000001101,114013400011030,101201104040034,101020111030400,103004104010210,101220024041000,102010300201414,100202200003011], + 1043043042131340: [101022014222024,102203344011410,100021324100000,102103430210003,100012014300120,110100120400020,102414014022212,100032000101014,101430211012120,100204021000012], + 1130012201033220: [102400010200011,101002041000124,101413321300222,102122001404300,102012421124224,1211200120132310,103313431403212,110222202033213,114310224030143,111214003022100], + 1020110402111022: [112004300230022,102300030220022,103201311412000,110202001000101,101022130300021,102202101300230,111200004440204,114000102304201,112010101111102,110243100000014], + 1430140000003320: [102202204040010,114200402332011,103333040110114,101022200343023,102000000221222,102011014001111,102331201001140,102101001342004,102103001414002,102022011101012], + 332121301003040: [110403302023130,110001004204310,100010311020030,100020000200000,100141230020203,101031121003021,100200120030203,103111201443022,110101214400030,114104040220130], + 1120411220011023: [100200101000000,103110431441100,100011004340114,100011200121231,111201102224324,114040020021023,111230114102201,114201102342110,101400300300111,114430204112100], + 1020124010031010: [102100404000000,101144424002230,100040240023421,110200110001001,100012421031241,110012110022022,100010211220210,101401011014022,112402412301221,110112031341002], + 140012210440003: [101000410321210,102001041100103,111102324104110,114021004100002,101300201001300,102100221400312,102010101130220,102304331000110,114000100041333,102330324110001], + 102001000022012: [100010104331200,110010104201022,100012031032234,111132300020000,100022301030201,110302030004323,103040301410224,100040010000023,111000302232021,110220422230001], + 214200213000024: [104100012102004,110030002000422,102102011413000,100402431012022,102403404004110,102031024013013,110044020020202,102122410220401,110301311303102,110021232000021], + 1013100140111003: [110101124221101,103300014023010,101421000301032,102121122000024,102301004113010,101004004003140,114020014100200,102320214110001,114411004143412,114000312331020], + 1041002013030001: [102040431121110,100400002201113,114111100021420,112024212301420,102212000200124,100300310140241,100240134323001,102042000222002,102001011100100,114402104142102], + 1040340203100012: [100410100030211,114110034120300,102410031403042,102320241001011,102013300200042,101001030303020,112410140202000,111300204123114,114040104103220,100020310101012], + 1000020244020400: [111300232202103,110122120100022,111100424100021,110111121011004,103001020104102,100242444300104,110002202001202,110200422113400,110022300021012,112000000223310], + 102100030020410: [103044301431001,102101142002021,102010220220022,102301044020300,103211001412040,101004114210003,100403304320200,102202030203203,102213241100111,110200024432011], + 1000003400010004: [110023002000211,110031240011133,110010000002013,101140021101302,102401231110301,102010404010110,101002301110132,100001101040302,101400001014101,103232330101002], + 103100402200010: [101000141031222,102000421131000,102020111324004,100421242201010,110200200001000,114023024101231,101410114043204,102101041341001,112431402022004,110022411320200], + 1004004001004223: [102111432002020,110211341302302,112012002311040,112011020211403,103200021200400,103040310110122,100323420421134,114121220031320,103210400104101,111011044400101], + 220122010024032: [112012111114213,102230004030112,100100221012100,1002022012411300,214021333002200,112102000202302,103013200104400,100130401022113,111103304400022,112001421111242], + 102043123002200: [114000042302220,112100404022020,102141300232324,102301024110000,102020201410111,103002421431302,112033432004122,102341100242122,200030234030020,100310221003110], + 210020003213120: [110104112010103,111102004100101,102202414041044,102000104012232,102021100220101,114443330001442,100230120001003,112042110220004,112203221102231,114022400020320], + 1040024313000030: [114134334101203,103004010113000,100431024302303,112004020202021,111201002224213,101110311041004,110101100030120,100413201001140,100211020412021,100100024030402], + 201120302001024: [101020100322242,114300420002320,102000220240200,100320220142241,102023231442022,100012004201010,100120201022022,110020040002032,111220432220020,114202304110422], + 121222222024013: [110202000002301,100021401041100,114020000011320,114002204011413,102010111411204,103040020122222,100031001030010,103433144040432,102310201001420,102031200220232], + 101202201302202: [100040401020114,114202400210000,100302014210100,114011012304232,100043111020130,112001201110014,110213300002210,102402200200000,114103040222002,101020124210122], + 1040441010340224: [111212022200012,111412020003222,103021020002400,103031041402200,110231202040203,110302242202220,103010441402001,111121004402312,101110231041223,103221000100141], + 142101230030010: [112413224040101,100220100110400,101200031020230,102403004042342,101024001034211,111122004101222,114001012300002,102121100232012,114000222213021,114102330210021], + 323101010222201: [101012400304201,100031044300340,103212014020132,102102030214401,102021420233130,103220300101010,100102104301413,111130410020021,101022000302211,101232020300432], + 100003431201032: [101444024041143,114121002310100,100001101023021,103020001400040,110200332041001,102020032000000,114004020010203,102023214001142,114002004033124,102222420200211], + 1012034133040002: [101010020320410,114003202303312,120000042021310,102103404004000,100300414022102,100000204100420,100221040432012,102110244130222,111202012220424,114121102204304], + 1132311020100101: [100000001220044,102022200220022,102140114001021,100040400100203,102410111110002,100101041040330,102000100210400,114102302311211,114034400040402,102122000212204], + 200314001211101: [110212214400114,103001001421100,101230011021204,110201110001030,102302000242323,114200022331002,102330104033012,102214401124121,100002001003103,114004200010210], + 220242102101030: [102101401400100,103032104010203], + 210330221122011: [100030204300220,101021334000222,114010122330030,100011024201101,111222442222413,110030122102303,103044001412002,102211124032000,110400200000240,110101301000001], + 100334401132240: [102023104002000,110230010000000,111114010020011,100011014101313,102011114000320,100001204302200,102100101140030,103120334003000,100000004204201,114002104011010], + 213434010220231: [110024021040134,101230044012202,110301001232000,114000012334010,102001201443121,102101320234011,102400204022024,102002101410204,102321400210323,102111002004022], + 1030020200302040: [110020301220324,100041000010302,102020100243032,100031001020040,100104001041200,102012200202303,103222114034232,101110404021211,103110041442122,114210400000112], + 103022012003010: [111220202240410,110114002004014,100010114200031,102341041000204,110040112132130,101224110303300,110003020001402,100204004121023,110100200402003,114001000010302], + 1040210203231102: [103122114004113,102242301122200,110030110122402,101344140314114,102100201400122,102110001141443,100011111022300,102001011120002,114032300011302,100234004033234], + 102204211320000: [100002021042230,102122220214101,114011244103110,110022224202024,114112012310000,100120210410001,114043402214302,100104210400100,110213042222211,110002100132300], + 320200002321230: [110032211204214,112002132303300,114420232314210,110103101002440,112432104012111,101104100331011,110130240011301,102002410220200,102002101410044,102002104011330], + 1102023031211402: [110430000400002,111121102240240,100101130423301,114000100020002,100040321020030,100400000010033,100400000013010,100022224212020,112020002002301,102003320200100], + 1010111201314040: [102040431121110,101221020040220,114111100021420,112024212301420,102212000200124,100300310140241,100240134323001,100103104302044,102141212000200,102042000222002], + 1032202230012124: [102000034011002,103204000110000,100001014340021,114203202330210,110214110004122,112032000211000,102300121000111,102331221102213,114212000211101,110021204411214], + 1010021201242342: [101210121032211,111310114132200,100002311224241,110430030000213,112031204023020,100022211040222,103043001412001,114332202301021,110002030413104,110041302001023], + 220013411003310: [101011004212201,101010304000003,110032022002020,100214230430124,103031234000122,102044021101411,101042001021012,101100104002023,103230011412301,100102001000000], + 1020141212421032: [104404322124241,102032031130301,114030234020304,102200124012000,114002120023020,114421000001111,121400013334402,114413200000230,100103201040210,144000213202010], + 132221102102000: [101400004022112,102200000200201,103110020210000,100022141030334,103200211410311,102100404021014,102303001102431,111441004421100,102000200223003,112030222004121], + 1020000001300010: [114200212322001,100401210020002,100010111022102,100220300410430,101024201114010,102412220200003,110012222000144,100201214123301,114302122323101,110431022023040], + 1130331004102100: [102023324010020,114000004103003,111131002212014,102110100233222,102120311402124,103140124002022,101042421021120,114013204013220,102000100221400,114241204001213], + 1141240012302340: [110011414240022,112004202302034,102100104000040,100010044300003,112120224040040,103301410110110,102124031023100,100204104320231,114002104020100,101032001032200], + 1041403000014002: [114101024120020,102004011440212,103140320213200,100000001021013,100011204300012,114003134011032,100101234330123,110024000432310,102012101443110,110032220022103], + 100110011012100: [114110002202241,102102004030020,100002000000003,114000012210041,102002100202041,110301302001430,101023010304010,101131011104040,110000012230024,112010130232300], + 1001244040010101: [110001041213031,102300324010203,102100142002204,102040011121100,110113004402201,110104002010100,100030024303023,102042204000300,100001134100120,114023214101310], + 1022021010400001: [101201211002121,113220210222001], + 1014210214100020: [100404404302042,114010010024103,114020444100202,100004004210020,110202220010410,104100010014103,100404000020300,114241034113010,100014044200222,102110142004430], + 124332301200240: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 131010000020202: [114221114103012,112120120202201,102010440220124,102122211440420,114133102311014,114400004140002,102303104110000,114444200000122,100244001003311,102200204033100], + 1120302040122310: [110200100002031,101420310301020,100020330100100,1002443410030003,111103224103001,100011231042030,102100141413100,102110021342213,112002310211210,100010031020102], + 1011443132101100: [101230002122040,111124004101012,101210241204043,104102040011120,114103220220104,102120004001310,102430121110340,102020121102120,112141104020201,101200111020111], + 1010200033100003: [110220122044010,110042304412204,114020124021122,100002201003312,110110111010042,102230121120000,103300001402013,100400010013330,102204011110020,112111400203031], + 302000003030010: [112210322040121,100402042200000,100010111022102,102000224000000,100002104302110,110030222130000,101022440300020,101402010301000,103140120112001,110204434434200], + 1122104440001011: [103030420104431,101421001011423,100444010421002,101040214213002,114033010011401,102222320200001,102304014110202,112002040214231,111100300024000,114203000003434], + 244342100044030: [114001204020002,102010221411024,114230000001013,112012040220020,100010201030300,112420104040020,100233014224240,100403430013124,102030001131120,101002100322211], + 1023201001004030: [114031022302044,102031011441221,114103020221100,102012030213014,102003320200411,102002024000132,112440114040203,101044001032114,100401001011010,110031200023240], + 1100202300000313: [100030130410021,100000020012240,100040034301300,101010244213120,100010001014210,102103210214042,100200100401300,101133024000013,110401030000402,100011404310200], + 1022200020001200: [100010400022200,102420221112201,101224044041002,100010344310042,102103214000210,100402012200112], + 232002320003011: [102022004012201,114201104111034,111130210020000,101022121001000,100000024210130,102034221103124,102300104110002,100024000101404,100020134212021,112001120220130], + 1130103021400102: [100000100100200,102010020203010,102200010200000,102001241410312,112102100423402,111131232212120,114444012310100,103140100210101,102323001001000,100020200120032], + 103200103012132: [111133110023322,100400024103122,102000021101201,102141300232324,101024401112120,101001440303020,102000124010400,103002224002043,110140141201202,112012030233024], + 1440130113021200: [110121100004131,102000301101102,111400214442024,111122200021102,114032234033303,101041100300001,100000020201032,110102022000200,102200034040443,102323004020100], + 1120320131223141: [101004120224442,100413311002132,100320421001431,101233021020010,110210301200101,111131102210013,110400241240242,101001024210000,102210101121104,102000324010303], + 1400300000440232: [100030010011002,101021301022041,1043303323011400,100402300013130,400040001020004,114200022340011,101201220402420,1001120000022000], + 1023020041401422: [101020414010211,101142004000232,101410021100102,100110004101000,100040020201004,102000034000000,112400200201000,102221204020110,100103121021000,112100020204342], + 220040241220103: [100002121043000,102400234020130,101202001022000,100133204300040,102000124002111,110400410030000,102320100242001,102200031002000,100101021012040,114021112304224], + 1101104002110311: [110200411140130,110114120120100,103124210100201,111014200024034,102301002004242,112020014000340,110021404214210,101003014210212,100130220400031,100210024300001], + 1004422144020030: [100023324302420,100104341010424,111121004103434,103111201422013,112203001103411,100212024121000,100001001033200,102441030231300,114121024121404,102304110220101], + 110320230001124: [100324400111300,110320024422004,110002022103210,103202210101000,110022004204211,100010200012114,100002030001021,100204244330221,100022024100220,104032200010101], + 1222121220311102: [100121230031032,112000431120410,100122200012014,103042024040104,102304104110001,100104211044110,114241222321321,114021002302020,100013200100011,114104200220022], + 112110002131310: [100310120141002,100004001021111,100301421002002,103022021431010,103200020111014,100010004313001,100003000104203,103104200210410,100002200410030,100121031014040], + 1420040230200021: [110013202003320,101031241000010,102120231343224,110030332100203,114404232310120,103100034001310,114002202210331,100031301020100,110111032140220,100020010200022], + 111402100102040: [114042032210200,100011120101004,100000120412021,100030101041442,114242304004011,102302200241241,101202111022400,110201040003402,112211022031124,100004201233320], + 1400202004010010: [110201122032010,110422210003030,102112231410401,102430301112032,120123111200230,114002102211121,102300104033220,102322214020000,100222000432020,111012124400030], + 1011220020200204: [100002201031130,102003104011100,110011024414011,103300204014142,114203022320321,112234142031230,411231400122100,114201130210110,111101222240010,110430400101001], + 103324014001014: [102040431121110,114111100021420,112024212301420,102212000200124,100300310140241,100240134323001,102111024000402,102042000222002,102001011100100,114402104142102], + 1140200210334002: [100010441032031,114402414111240,101231211020143,100022021024200,102040444014121,100024100201424,101012011001200,100003014211000,102400204024124,103241134020044], + 102020002304410: [101121211101004,101114101012020,101001304001101,103000110142041,102002112041034,102041111020030,110022001201023,103101124003110,112401144042000,110002001231100], + 200342310201020: [100000211041234,101130000023030,100200400000010,101221200010202,102100014031110,101010101034002,100040001022001,110004342121110,100100340412100,110030104412010], + 322042110301230: [101301014221122,114110200212210,100102224033421,110012130410040,100104101200201,112201010203210,102021001411110,114222010213042,110041102012100,100120430411222], + 104204022104122: [112303041103203,102100111341030,102020231440400,102144200210031,102121104130242,114104220000003,100112011040312,101013200321014,111000220020441,102211304043141], + 100300143300020: [102111220202433,100100431001421,103030001240001], + 1040311120340120: [101000404014420,100020204211040,103010144014002,102020301413010,101112020330001,100021211030200,102220201302400,100023221020004,101012130300004,103001010101420], + 1004204203001024: [110102401201204,102200130202201,102414034040100,100212030414010,100412200002013,102020041321410,102301324112020,111340300010010,100120421044222,102110042001220], + 1110021032011401: [110200411140130,110103014401023,110130102010010,102301002004242,110001010030000,110102202013213,110021404214210,101003014210212,102024000201400,100130220400031], + 101101134034100: [110413340401411,100201104211021,100020104100331,100432034100300,100400040020030,114021140030212,110420241240103,100030200001122,100004341223313,101200101022022], + 132312120020420: [112113214020100,102010202004402,100000130013400,111130312211003,103224041400220,100001321032243,102104244000010,101001010300404,103340004020422,102410220200004], + 1000233213201010: [101022000320420,104101000012210,111010200042110,102202030232200,101322130310304,102200110234042,102102330211000,110002001312200,100020014211012,114123000000123], + 1004002300202031: [110002022002032,110000242002021,110042130002002,110211114244021,101010000324423,102421340201120,112000020240422,100002204300121,110402332010103,111111110022110], + 1023001031200010: [110000212101040,110301011234204,114211102321011,102110221412210,103330421400224,102000200201422,102412004022002,100032204200023,100023211030203,102104301004310], + 1042101141021002: [100001401221100,101204241200204,104100212101311,110404013244040,110000001210300,101203134230142,110142101000021,110141004132001,204144002130204,100001131021011], + 1001200003422220: [100040020100400,110104010020022,110000300030110,110030010040441,112100300200332,101220030300042,112200211103401,103210310104102,100110204030443,101030004010100], + 300120022222042: [100114004100001,112102201102030,103222244003021,112440114040203,100401001011010,103001204002010,100340114211043,100033001220020,101100120334014,114233002340141], + 1010031331102220: [100003020421130,101120104004011,100333004310032,100402010020402,110120100120410,114220022321121,111202220001312,114024120021041,112004002002243,111010414402003], + 110301213122224: [100121014300312,111144004103013,112012030221400,112202022022311,111000002221010,103020031400120,102000114010112,100110024300032,100012431020010,110220442220001], + 100100220042201: [100020004313034,101400120320033,110430030000041,102140411342420,103243024040441,110021014412440,102020004000301,114114204001401,101042214000121,102000121102220], + 1103000100120411: [111112002210022,102024021130010,103211010211331,103200224020100,112012010230002], + 1140011020023200: [112413224040101,100220100110400,101200031020230,102403004042342,101024001034211,111122004101222,114020040013100,114001012300002,102121100232012,114000222213021], + 1102424111012101: [100210201001001,101000224223002,111120402212201,100101021021114,112240000413000,101040201112304,100100301021212,111011024411424,102130000312131,100000101223200], + 1010310132014010: [103102101422031,102100221340112,114002244103320,100000001020034,102101001412044,100012001020221,102001120222010,101000031144204,110221002033200,112103014021210], + 131033014100032: [104111102100000,110000102100212,110130042014110,102110410204321,114423100002212,100011401040040,111121012212042,110022134200011,112320030202004,110012102130100], + 1003003202420203: [103111420110210,102022400203211,101214240300041,112430210020301,101002110310112,114202044001301,102021001414200,110000014413004,100404400020001,102100124000134], + 121212202001201: [100020004313034,101400120320033,110430030000041,102140411342420,103243024040441,110021014412440,102020004000301,114114204001401,101042214000121,100014300000200], + 1102042200320021: [100200214321010,102303024110011,100010040412121,100001040112010,100030101033421,110002222104304,100013140102040,112003112302111,100000340413320,101011021020240], + 120111412313022: [102213210210004,101220121101403,112210141104023,234010311030401,100003030202011,110103420020232,100010041001440,102302421103304,103220010130113,101210020303000], + 1022413444114134: [102100221340112,100003414100400,100114104101001,114002244103320,101023221000031,102012034000402,102100122002001,101000011021414,102102201121020,101000214211011], + 204230100241112: [114202120000302,101000314012210,103204020100331,110414222010040,110000344201200,101044230300020,102100000201214,110220224213000,101032400342331,114014220021140], + 111140041000211: [112413224040101,100220100110400,101200031020230,102403004042342,101024001034211,111122004101222,114020040013100,114001012300002,102121100232012,114000222213021], + 120041221022240: [101021134011012,104120130021200,112421004012141,102011104010201,111100220022101,100021104201130,110030410040101,101300401002320,101110434020010,114330002300133], + 1022031000130304: [104100421240110,110024042103114,110213012044343,111113004102021,100012130010240,101001101031102,100014014203023,100230114221102,110041221200014,102202121300311], + 1400210001031204: [100000000004323,100120001204102], + 122002222004211: [112224111100141,103030411422014,103043334040203,110422201312402,102120131401230,110302011332024,110200302024000,110021340020022,110210020104031,113130020101411], + 1014120100001402: [102120031140142,101021204010011,100404410022320,103012101410102,102131304003000,100002204100101,102220220201011,100222044100141,101400000300101,102000110222120], + 1040010100200410: [100403200030000,102330130243430,112021400230000,111344004132104,101200044013000,110201010013331,110104120000112,110322102100121,102110031144222,111100024421114], + 230000002002020: [103114010100442,110400222110100,102120244001000,100002411024300,100112101040103,110304220401302,114120444000124,100110304233020,100104004030002,100101000402002], + 312000302021421: [110110402011142,110210014220001,100010010121321,102140011440001,110401112220304,101011220342010,110200004221020,112241202024021,101000001110010,102000300200231], + 202213100022144: [111101010010203,110110212010011,103120101441202,101002121003112,100004104210221,400014404414011,100000010101402,102010414013103,101201021022111,114100030221300], + 210000431200200: [110114001202122,100001010100220,114002114012041,100414031001210,102000004012011,114023102303000,110101100012002,110001002004240,100030220002102,111010024401332], + 102302210111114: [110012244202012,114220124140201,102032011134420,111410022220201,100240220112202,100001020001222,102210201010102,114104422324400], + 1102440343040140: [102402024000034,103012024004312,102214020242110,101140320330114,101010010300020,112120020230024,100000204100304], + 101020100040202: [111001440020003,102001000212142,110200020010003,114121000002140,100002214100100,102120104003011,110123042010000,102120402000014,100041000100422,114020002303212], + 103211040042400: [100041000411231,102140040210040,114204120210000,114110030002020,102010031444104,102410010201202,102202244040132,103303001400240,102442004024220,101224231020422], + 1122100041103333: [100400210010032,102011211321000,110010144200414,100142244232110,100210014343102,114002242203043,111122412110000,103201431202043,102423111110121,103400014003022], + 1412100222102320: [100003004302243,101221214042201,100210031002311,110001000134002,101203000300012,101002424000211,114102002341430,110420222224222,100214214101020,100000004311204], + 131012331014331: [103101200221334,102003040210002,110041001300210,100100304301220,103200004030010,100400414300130,110332030011233,114000210010231,100021101220000,100011104103200], + 110311413430130: [100122004300410,112400202020003,102000224000011,101212040303123,100021021000101,102030200240232,100011124202310,100030300124130,100001100013110,112233332034000], + 1141404232302001: [103310101401010,401300041114001,112003000230001,114000044101422,110003002010301,100003014101004,102001421410020,102001134000000,102004414001114,100420021000320], + 1010242010112220: [114034030020130,100000301031020,100221000031141,102422310203100,111120020014001,104130142103020,114224200210241,101010244002013,102343001000312,103400021212203], + 100030302212140: [110020301220324,100041000010302,102020100243032,100031001020040,102012200202303,101110404021211,103110041442122,114210400000112,114042014102321,112003110242131], + 110204242100032: [101204004040140,114000224121024,110344021203140,102200310230230,103001134002100,112020002001230,100022020402123,110441340002101,112000030210004,1304211130012304], + 1140000210203143: [112132434020310,100000144104100,100013030100002,103340114022112,101014014000004,101033141030001,102111210230204,102200421003014,103214430100103,114000212300210], + 224400342004020: [110101210013000,100404121014002,101240220300022,110120020002304,100011000202214,100000024100000,110012101102100,102102304001200,100010040001210,102002020220000], + 132000014424004: [101021120323020,114111200034310,102001111412134,100001021030011,103230040101112,100010041032043,102110234020204,100004131024040,102441311400421,114020214033220], + 1010001003034302: [102021401410001,114210410000401,102002410222340,103210214003143,100110000020111,114401000004202,100024104100032,102100014132110,100021304103002,114001012302043], + 102042304000030: [110021000410432,103202000110102,102020440220202,101010010320112,100042000000000,112000021122010,100021111043012,102122101023020,110124041140000,100010044101002], + 100304100012010: [100023341032000,110121001321020,111112402101001,131120400002024,101001024040001,111203444130002,101202110304201,103103243020231,130211430311301,100422021411001], + 310021030012401: [110000024201210,100044004100240,114403000001001,102020121321033,100000421021000,110010120042000,100024330000002,110102022041040,102101100232020,101002000310100], + 1100102002200001: [101400401012014,100403402200101,100213001002313,101001000200001,103140404001201,110024021232043,100402000020330,110421010000410,112210000412200,101024104000402], + 241242413100310: [101020000323002,112112014020004,100221020410001,114314004030042,100111001020220,110321132002134,100411000433012,100210024221001,110001101011030,111301030010001], + 1200202101100010: [110113004402201,100030414300112,102104020202131,101300401004400,111101222244101,114112324000301,110220022100020,111430412213000,112023202310000,113404132421101], + 1100431000211240: [110210000000201,110040421041000], + 103301003032000: [102301324112020,102100001400000,114404020002102,112102002010300,114013222204012,100011401030000,114212034001403,100000000012342,100044004301023,114012114030220], + 1011344402021011: [102230040200031,102442211414022,110122001010214,111010214402000,102101204000010,111231012220013,110022300420031,102000324040402,100100401040001,114230230000123], + 1433202202104010: [100002024201011,102004410220430,103220120212134,114200014001032,103013411431022,100344101004202,103044004012014,101040004222021,102400004020303,100001214210212], + 1030223414223014: [102200130202201,100001300012442,102414034040100,100412200002013,102133001404002,102301324112020,102400101111034,114102104124000,100120421044222,102240344041020], + 1022100200001100: [114130012310000,100210201001001,101100001101401,100243120430140,112214431102032,100210010430242,101411001011011,102211241120212,102130000312131,110120032013303], + 132000130034242: [102100200234203,110203204241122,110001214200042,112002242001000,100021111211003,112010204003014,102032220221210,101032240320040,112001302302020,100000004310202], + 1140124010014040: [101003114002014,100202121002020,112220000422230,112020031122001,110220020001020,100113414201210,112000000210212,101021200320340,100044100002002,110041001302020], + 130021204021211: [131402001003121,114420000001024,100304111000014,103300031403210,100022131043110,102010021413001,102040300202332,110010001011032,102100100230142,110030140000021], + 103004204041100: [114201102320021,100001004104043,102104241412020,112014402034232,100110100410210,102000000211031,114333212323001,100002214201101,111303034134331,101402041101020], + 101003100020334: [102010221411024,112012040220020,102430401401200,100201211003004,102030001131120,102221414000020,100011214104320,110004204420320,101230031023440,100023024342204], + 1140300100120200: [100113214302002,110000002133140,101233341022410,103021000144000,100040204240000,114100012313002,110023002200241,114440440000034,101004202403121,100304320140012], + 243122200030101: [102232120200100,112000142000331,112100302012200,100022341030311,102010100223003,102101001341304,111004314403022,100402100022022,100040210100004,112042002002400], + 1420240002010223: [101001040340004,102424204043100,112022334022101,101011324004222,100300211000020,101410401010030,103210241422022,103240001403000,102202204040220,102121010212140], + 300002111204404: [114423002313120,103100010101002,102300041004010,100241020000000,101403004040100,103000140101310,102310204023400,103111240223100,113104030104020,114401010001000], + 1042020101004004: [110000112003030,114243240004343,110300024422133], + 210000320003221: [114130012310000,102112432004423,102402124022000,100243120430140,112214431102032,102032204000102,100400120013011,103011001244001,110120032013303,102101230310000], + 1440002200022022: [101022014222024,102203344011410,102103430210003,100012014300120,102414014022212,101004411032102,100032000101014,103030104000102,111311002224001,100032134101100], + 102014201101304: [102133011413110,114022424102243,101223020300040,103111420110210,102034324000220,102022400203211,101230020303000,111340130010314,101214240300041,110214220002020], + 1423223123210030: [110043132100300,1321200010022312,140403400240000,103002124003020,433402331200202,102222034401200,110030221221100,1330044041003024,111200100002230,402102020002420], + 100000004112013: [100100004100200,103120140210020,101432201010330,102143211343014,100112000410320,110124044400220,103002110114402,102012242000404,102100214000001,110233124211010], + 120142001110232: [114100204101002,101101230010000,114100020033022,101012034000001,102002100000102,103112021441120,110401101144000,103124201212022,100002001020202,100422100432000], + 111010000202013: [111200140000402,114303202300104,100210304340400,112020044000400,111201314412204,102000200204141,103220100102140,103041130110112,110023014202232,102220021304234], + 102142201040320: [101200100304010,100102000022402,100000001033001,101202404042303,100121231021002,101010200321022,112402002010210,102200231120202,101021220300001,101431311011102], + 102040200210010: [101013004002011,101300011002044,101011324004222,114000322300011,100002314302420,143310043400402,114411312312124,101010404213432,102110411342400,100022014100321], + 122024000000014: [110224314430000,102203301123001,103100134001001,100000001030003,103210400110122,114030314123101,101112020300011,100400201010000,111220020010043,114020142302420], + 1042200020200001: [110200400000020,100324140141402,103204301402123,103102224034002,111100100004430,110001001200323,110102111204210,103013100120001,102000000222203,101001301032024], + 100402243210110: [101220011200202,102211124010012,100411221010100,101420300301140,110102202210222,100200200003210,114213204002010,111311022202104,100414014102130,103030104000000], + 130000300220100: [100422211004214,102100000210002,102121010210004,114013214010111,100010004210020,112002100240200,100001404100110,101213110310042,101424044043122,112022221120403], + 322210210314001: [100121230031032,112000431120410,103042024040104,102304104110001,100104211044110,114241222321321,114021002302020,102313204114304,114013124030022,100013200100011], + 1100220132200013: [144131233204044,120130001004000,110400010031401,102220211120002,114112002313010,114014010033321,101400104042212,103441112000230,132042400010214,112030200211020], + 224121020102300: [110130314400100,100104010021241,114023142202040,114002014033200,100004301021110,101010124001000,100210224243223,102330020242041,114021300010020,114020214022000], + 122224100040420: [103001111221030,110042400130000,111200020004203,104101201240100,102301112004021,110000011012202,100201230412211,101301000314000,111010002110212,111121022221002], + 1123222000212401: [111200200000232,100101001011114,101430004040203,103122104002013,101020404210020,100000024301031,102220024122101,112022140234004,100143440001301,114102104121201], + 1010000022123200: [111000010041300,112000002003301,100200221000243,102400044023410,110423034242000,101020031030240,111204000003031,100012004110024,102142000210040,103243411400000], + 1100003101030412: [102102430310202,102002301410122,101001414212120,102142020212310,103304004023413,100022201043312,111300032204432,102002410201020,114142200030000,100030001042331], + 221012000100001: [114030230020144,110000120020000,100100134234041,100340100422001,110010002103101,103042041243304,101410200110200,110104011001220,110120010011024,101013021021140], + 314343000100322: [110020000030400,103210220100310,102220000202044,100001104102110,103101030213102,111311304133413,100000004212021,102441030200210,111110200020323,112400332010200], + 122020214140410: [110033000022043,104412212102010,101230004040022,101021020324310,103140021211010,100020140121034,102340211000200,110414012023214,114021000044211,114000200010000], + 1110240400400121: [112002140242302,100022140001044,100010204103214,110013100422233,101214301020044,101213412120001,101001311004102,102202111100020,100100041020000,112412202010110], + 120100310012122: [100021311233000,110020200420132,103111104030033,102300024110101,111010204111010,111200302222011,112021221130424,100113144300434,100010010004402,102021310220414], + 100013303040013: [103100021440001,100120100032121,110000201324002,101200400331110,102200302000412,111201022200100,102100100210100,100002244341113,101000141033304,112400230200400], + 140000210113020: [101011000322203,101012130310043,114102344121242,102011001411100,100001410411142,114003300023020,114421102322111,103224324020100,101423004042333,102104020232002], + 103100220140000: [100000241020300,110002012000400,110020422131120,110043414212400,100402000010424,100002004301002,102000124000220,102113002001101,102140011343001,100030020010422], + 1002031233000321: [101222101202341,100020220410142,110000412003001,120202201010210,112042024000020,110003000024101,100010024302100,100000011020412,102022400210202,102003034011323], + 1001310141442432: [111210044131101,100021100013401,114032002303014,101242421020211,110310042021341,100204011000000,100000001224221,112301111130031,103123200101000,101002401002132], + 1020222312400100: [102210100313100,101200210302201,100004420014012,102240210240022,101040401032021,100102001040033,101242004043300,100002324211100,112100204041010,102024124011010], + 1000013340001010: [110000101304203,110040020001022,101104020300301,110010022003021,100401241014100,102101004000011,101401001010021,110033002000020,101200200300020,102010214004210], + 102401001142343: [110000000441321,100120004300000,101211011010400,100022411221040,110212300122200,100121004301043,102010021101132,111220204102302,100222401210112,111101210030022], + 140004212101020: [111020120021001,102422221110121,110120010013100,110410004221142,114003044024423,100432201000300,114022200011010,100011104302132,102103010200201,102040031124231], + 212430302310110: [104100002101431,110221000111302,110022140120012,111330020002213,102011440201423,100002204310140,110110210011002,100020320002000,110101210402402,111130042240210], + 103020323300000: [104244002023000,120133001040211,111320124130040,114012412200022,110000110000231,100142041012023,110000000411120,110302100010342,101301030313022,111440222100012], + 1023113301404241: [110002420020000,100020010010020,110003001101020,112011340213224,101300011002200,110311020011020,110002100043200,100204130001213,114441400031030,112213100413130], + 133011400041002: [100420021010013,112101302302202,102212011120200,102344111104233,100432104320110,114021014020000,102121321340000,114200214002024,100111221011100,100023104101340], + 1431220014210200: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 113020202032132: [100422040021304,102000024011300,100002010413410,101011210300000,101002221140440,102040021424212,112400020200104,110324444424432,100100001010020,101000000322000], + 121021030422100: [103111001422000,111244302220204,100042100102211,102110030200120,101114000332010,112112211102024,114001032300011,100142044103021,114004014011110,101100010012423], + 1410010043031010: [103123041444340,114002322301113,101431311011102,102211201110013,102142002001031,114220110000102,1320030020310312,101210004012132,102223240200000,100102044302112], + 103221220012000: [100203321001221,112000210242204,100100224031000,103111001212300,102310400244210,110010112102022,112111040230130,100004101023023,102022304023433,103010041241404], + 1030010032040310: [111214100000104,102103034004032,100430221011100,110422010000200,103112021442033,110044014410012,110030231214100,111121012243322,110100144404220,102420024020120], + 130210202000000: [100020004313034,101400120320033,110430030000041,102140411342420,102020004000301,114114204001401,101042214000121,102000121102220,100014300000200,101031101024100], + 1001100022400112: [110001202003004,102114101444001,100022121031020,100103240011013,100020210101002,100042420003120,102300220220432,101020120322020,103130004003141,100043240102000], + 1041104220001241: [100001201220014,111001200041102,100210000032400,110200422121211,101213311020021,110040411222022,100041120200010,102303001003004,114010312213204,102140004002412], + 100202423330142: [102414440232000,104130210010324,102201204040211,110024102010002,103010034004303,101324030311010,101402001013023,111433000002144,101434300302410,101010231002430], + 1012022120223104: [100131424302300,102104004021010,112033000244420,104132001240113,111221000010010,114302044003120,112211222041401,102000100240000,100202234032222,114400220000013], + 101000002200242: [110421202022110,111142002114321,102101020220020,102030030202212,111420022210032,100023020100300,110013140400124,110103334401021,102201121001214,101000000341320], + 121041001123102: [103102101422031,102130124130100,103214021400010,110100022010014,111110420014032,103144220102102,100000001020034,114440020003320,102101001412044,100012001020221], + 122424002020134: [114400034111031,234010311030401,110002201200100,103120044002023,101121420321412,102210004034010,101010111030103,100430020420000,100422210013104,101210020303000], + 1201010010230040: [110010000111020,100430014323000,102011041320000,114240012324120,100022010022031,102014140200013,101240110302200,100031204311023,101232001021020,100012121040101], + 131411004102021: [104100421240110,102001000212142,110024042103114,100024121030022,100012130010240,101001101031102,110020422130021,100014014203023,100230114221102,102040211440200], + 1000241110002220: [100020244100302,100002200412020,101320310311403,102024011413201,102331201001140,102103001414002,103222024031400,114001042203020,101002004010200,101102301100010], + 120410041211143: [111004122201200,101100104021220,110132200012004,110030441210222,100220134100412,1301000101110210,400142440224000,103022040121103,1441130121130001,113411000100230], + 1100122034120010: [100022001022231,102314032000332,102300001100200,110420020000202,102023024010033,100001144201220,114240010000411,111212204101240,103210031410020,114430000004001], + 242123101000102: [102000201100400,112123000200343,110034120023130,112121040200102,100134044003303,103002004002222,100121100111000,101001401032000,102000110220314,100143111222020], + 1030401420201234: [114020000030002,100201211003004,102014002000401,103103241421322,102030001131120,102221414000020,114121012340044,102000400240203,102104304023201,103310300140324], + 210010010404032: [101420104040010,101201201022032,111301210041010,114340002303220,100021204100214,103144224004012,111344320041124,101120011040200,110042004410444,102043040200002], + 100132312020010: [110042220002210,101112404231342,110011401011100,102221200204022,103021030102410,110430314220010,102423100202400,100004014300341,114100212211004,100020011230424], + 210200023300222: [100214121000000,100042034200032,102011041100210,100200021000412,101400240300010,110330000400112,110103041012020,102412241111002,100424104302020,101013234000010], + 110012141123341: [110320442100100,100030000104003,114020012204013,101020224003300,114422000000001,100411410002011,100044204210304,101200220300302,111201310013231,102100101320311], + 1011002011031422: [110000204210130,110222020012300,100100100422103,103101001422002,100021140000322,110010011212411,110102322040111,102002104011244,103230010114302,114010304010030], + 203002012302021: [100021414104212,100030001033120,111021004400020,100242000000002,110011114214043,102420314024020,114111202200420,110121002010041,100000101030212,100203041200002], + 1204213141330013: [100100021040144,114101404004011,100102404100430,114142044000010,111230032242001,102300200221021,114322222322000,100104020022212,114024104032203,102023110212012], + 102021222031240: [100020031000013,100024004310330,111100012111200,110410324244300,101001001000302,111034020021310,100110040411303,102101030311301,114121012211212,100223401013100], + 1001230102424402: [101004201002001,103112010213010,102121001410120,112200410200142,101212000301013,111400002102112,100034100124302,111112214101000,1320102201231021,100000040413022], + 320300002010000: [111101034100200,114003410040220,114021004101032,102001140221330,110332124420001,114221122320002,102010244010004,100000204310000,114104200000400,100011000410042], + 1010421111021020: [101230114202200,100400000020230,100002200103104,114300124030100,100431000032001,100202031002101,102021024004322,100121114230123,102102334000400,114323400212122], + 1010002000010022: [100000100100200,102010020203010,102033021130021,102200010200000,102001241410312,100000121042240,114444012310100,102330021000131,112041031114021,110400240002411], + 114210100203001: [103000104004220,110243010010124,101010340331320,111000024410303,101100424003101,100201401010000,100241131003241,111002212200000,100220310411013,140101212000204], + 1014111400001131: [103134014000340,104103100010141,111101222240010,100040210411102,100110004102034,102040140220220,114010400014304,114300132321233,110000140032001,102033340222200], + 101200430240230: [102421011111120,102100004004440,103423101410042,100012044303001,110113222010020,100220211001224,100042444310422,112220114010021], + 1004000044030131: [102300221004024,102031101124431,100003314102102,112224001100103,103100014000022,101144404004021,110020400130000,100411004100111,111010004110221,113114001024000], + 121021322032443: [114011114123044,103042141430211,114403210004014,101033214211000,114142044000010,102101404000000,114322222322000,102003104000032,103211301411024,101122124202002], + 1041103000010020: [110140300430002,100021300412300,100002430012110,100000211021200,111122000031124,103013000110110,102420244023112,114322402322100,114400244140102,100132300400011], + 213110000024004: [102003104011100,100011104344414,103300204014142,114203022320321,103134014000340,114201130210110,104103100010141,111101222240010,103110001420420,110014010003041], + 1020220102030020: [100023101042010,102112310210202,102330010243440,114042044100403,114221224002403,100013310123100,100022410101442,103202014031021,110212424242341,100101014300100], + 1011201011001041: [110121200003300,111040104401311,110102031222030,104101041240101,102400304041032,103121004000420,100040311024300,114110020212130,102002102043132,110041300410101], + 1000123000003000: [111012034402110,114221004034110,102140014002141,111100104104202,102302000220440,102002204000124,100011230120014,101104024002242,114220144000001,100400010013033], + 113000000242010: [110000112003030,114243240004343,110300024422133], + 1143241300010200: [101202001024340,101041310301004,110021122100000,103312010113222,110130022140122,101003101000000,102232110201100,111203040002344,110000000143124,110100042013221], + 141023021411330: [110130102010010,110100030123401,102301002004242,110001010030000,104100302102030,103200030110000,110102202013213,110021404214210,101003014210212,110000242104040], + 101004000200213: [110033000022043,110100200030100,100000411231000,100023001222000,103140021211010,101002124002220,100101004230030,103044004034040,102103012004030,102300231000210], + 1000402020041412: [102322014113341,101022104001221,100040201012040,110021422000000,112021004003303,101120030330110,114100222310230,100011120000004,114131002342130,110002022003101], + 320000000232100: [110212214400114,110201110001030,112300020201040,111200400003200,102330104033012,102214401124121,100002001003103,114004200010210,110200010000103,100001214300200], + 224230410221210: [114000120041100,110100002012444,110313012100114,100210304340301,114000222300110,100022201021001,114001212303000,110012200403213,100103244100022,114422104110002], + 213202220224013: [100010101043200,100030100004000,101001221022240,100401320020240,110201222120421,101000011020103,114121202312210,102212040312301,110010402103240,100020120112303], + 113012032020401: [101041301000320,100210104322421,110100001200142,103242311400421,100020001224324,100022340021012,102002001133122,110010204412200,110240010100402,102100220230201], + 104040021000211: [111122100010330,102302231004020,102110031342012,103001000141212,101202104010412,114234414102011,103211324003020,114014442200003,100103121044231,100101201041310], + 1101010001230030: [110402402020010,112421302011301,101023431001040,110001210120320,110300404422030,111024100022301,110200310012010,110102110124010,100000404341421,110000022100112], + 121144003201141: [114211010000210,110200020110120,100003040101420,101440004020212,102234400200230,110100201000100,100000004210012,110202102231202,102112000204313,111111024404430], + 1422130340314011: [100201030430140,100004024100043,100241214220112,112021142000002,101000104000400,100021000410443,100200144102020,111001422230001,110103002040131,114001110013231], + 101031043002220: [100000000102140,102200011002302,100402400013000,112102302301410,110001030430030,100220104020000,100341024211220,100400100020200,114104014001020,101042000300011], + 142104012100202: [110210400114203,100001100104021,101101300010301,101122200300011,112210201100012,102120200221403,112001122302311,101001211004233,102303011002000,102314100240010], + 1100100110012110: [102342214020012,100214104301120,104130011240303,114300014030310,100040004331010,102320234112041,112420030202242,101001424004240,110012021200100,110000200000133], + 140232403042002: [102111000202241,103232220103211,102022004010004,100202204222000,101201114044200,110422420000022,101412010300001,110312121300022,110040304210001,110033111221230], + 102014030304000: [112413224040101,100220100110400,100001121023210,101200031020230,102010110232121,101024001034211,114001012300002,102121100232012,114102330210021,102140320310003], + 120202411002010: [110321031234422,102342120222031,103021004014220,110302100111410,100410434302212,102023001440404,101023014004000,100020010101201,110412042010210,102312344020020], + 110221102021410: [100001101024000,112021240233200,102012020200430,101024000322412,112320330411100,112202332033141,110231222101120,110002002104010,102330021100410,101230111021024], + 101001021013411: [102010221411024,114020000030002,102430401401200,100201211003004,102014002000401,103103241421322,102030001131120,102221414000020,114121012340044,102000400240203], + 102012401042334: [104441021202022], + 102341202023000: [100200011001220,111202014132111,100003141022321,110201434240143,111030044110010,110041304201404,112101414041022,100040211022000,114000134102201,111103412240000], + 1000002421022310: [110220100000102,102100321320100,114042102330002,102102011414242,100041004100221,102310030240210,100000000412112,110000010033022,102330040242220,102310400240000], + 1402124300113003: [100430021001320,204020131034103,114113404003030,103214301421201,1000001214032041,102100204001030,100102240020100,114000332302320,102210000240404,100040004304002], + 1001424300100241: [112014422001023,112410310201130,101010200344040,102120044004401,114100220033300,103021020110143,102010400200202,103000004002040,114130114003242,103220104020120], + 1010012021012304: [100040240004024,100010000002400,112000013244041,114020100001120,120020211120020,101002041000124,102100000231232,102030034011211,102031111324402,114201404114100], + 100121010001240: [114033300040100,100313030142202,101221020300020,102013401100100,102043030202102,102300014110023,114230024111000,101021110322104,114420302320210,102112411341000], + 104111011231030: [102240221000001,112041002002124,114000024101102,100020124204330,112202412030001,100010000101004,111432124414000,112410140230303,100040024103120,114210142321120], + 1000013001100401: [102101021412120,110024020421011,100042014310200,100003014314102,100040224102124,102100011000033,100011214102010,102112241342203,100002004200212,110010332201012], + 144110111101000: [100002031120341,113020001020004,100003044210040,103243401401133,110012212132410,101210014200430,110014011320012,110400022122040,101111010020120,100223400002001], + 111101300123204: [111342430040130,114014120011010,110000202132000,100202041213213,112000230220010,100103021003000,110312102103200,112030402000043,101001020312121,100043001220111], + 103421110041022: [100010101020412,102203101113311,102100200221304,100001120400212,100122101040003,102100001341200,101421011104010,100010020410014,101001004003201,100040141042400], + 110021203010201: [100140010100100,100022111042144,101221201020204,101000314002223,112020240233004,102300420220003,112200004010122,101320400340000,110220102020014,100210011000412], + 122020112221010: [110130201302200,103041021430301,114000402211404,101000100302003,110343042000030,111302204120210,100203211002212,114140022340203,112032222300033,111300302202002], + 1020004441140020: [114001000020102,101020040300010,100213001000212,100002004212420,102121014002022,100141404233000,114131002342130,101020001030204,100403122201202,102303304020122], + 1101000000000402: [100044041022000,103003311430003,110402020001421,110010412101002,101410104020340,100131300422201,100014030414202,100401200033020,114002204023003,100100234234040], + 1444230033311212: [110201320000011,110001100140240,102230114040102,100244204311004,112001002030133,100240203220201,110200114241402,112020201122220,114000020043211,102000331322102], + 1102210000002002: [110011414240022,112004202302034,102122214131011,102100104000040,100023031000024,100010044300003,112120224040040,103301410110110,102124031023100,100204104320231], + 1110224000020422: [111302020010000,110204400000120,101300221003002,100000121020303,110200220010220,110020004203240,100020010420242,110001040133002,100100204232000,110031020114222], + 221402110224012: [112003002001002,100122204301140,102120100230203,100023004100032,103332430114042,100020014100010,103313021401232,102021224002101,114110200221240,111201004100241], + 1042140031004402: [103001111221030,110042400130000,104101201240100,110000011012202,100201230412211,111010002110212,100414004300100,102000020241101,112311000204002,112312041101012], + 1002200132000420: [102231130213210,102000402041014,100043324210140,100023024211011,100003201021001,100122020011232,110002021121023,102201100200430,100022010411004,114121300224141], + 1143041002141401: [110002320424340,102031100200300,103130311444100,114102134122020,101040004010012,103000204003200,114004030023211,111100404100043,100000120412410,101222220302400], + 102240012000210: [102011214000000,102110111410144,100031010010121,101001100300012,101041104222000,112000202310100,110001102102020,101012031033100,100400030013102,112023100230412], + 1100000411031212: [100002121043000,102400234020130,100133204300040,102200031002000,114021112304224,111214012220202,112001404000330,100202004323143,100302241002010,112040101110000], + 1140122200001330: [111011304114002,100000021023020,110013410002100,102000111441024,102001014002221,101110204004210,114240000000041,102120400200003,112440140200000,101013024000102], + 240042210123300: [100002004303100,110130010102101,111000122201420,100212034221414,102000041101100,100042004301301,100012021031014,100000201032010,100121301023030,100404000020000], + 131014040400203: [104310001300102,114021132202032,112012004004324,103001314001021,114122220031004,103040024041111,101004004213014,111124002211203,101211231023001,114022214031210], + 1100022000004102: [102111040210242,114110000002430,102010011412143,102323124020210,114013422300032,100201010110320,110101101120302,100040201030342,110210402031211,110221030000000], + 1100004010022112: [110001022000001,110002012000400,110020422131120,100001000100000,110243000001123,114024400030020,102102120210120,100402000010424,100002004301002,100103120023100], + 1200400022220220: [112124004022322,111300210014020,102103201320411,100100031043410,114403210004014,101033214211000,114001100024243,111000142201220,112102100423402,110141112044000], + 1410134011002122: [102004024000402,110031101012110,110231004212304,101124004002042,114210000210402,100022011220014,100032340422310,100100300004321,111334234120033,110234001301040], + 112243000110330: [100000020421013,101020024002022,100100224230014,100200110014030,110012404411012,102340411101202,103001204012032,114121224000302,102041314012004,100232000001001], + 301040112430410: [100002004303100,111000122201420,104134121240044,100012021031014,100000201032010,100404000020000,100010210410420,103000300124010,112311030201000,102430010202411], + 1002134003002041: [103011041410132,100102134031030,110233000100021,100112104301200,100021242211014,101001210201440,101110040002210,110211104432213,111401304441341], + 1012100302403002: [100013010004000,102200000204231,112020022000410,111232100010040,100010004203011,110001420003002,103230330100204,112033012312000,110021120110240,100401000022224], + 221013010204002: [100000410103200,100001240410410,101042201000011,102030001412241,101001204010220,100004301023143,114223200221140,101012400304201,100031044300340,112004021121002], + 1000210430142022: [110202012100020,102303010241010,111342020011220,100314114322101,102230130203001,102021401324232,111222102243400,101004410311232,101201034010420,111220410010144], + 110001002100022: [100021301030034,100020214240402,110014032200004,1113004122042140,1400000110100020,110400302220030,110013222003112,100104341202202,122002012004004,112124400420024], + 1040300031240011: [112210010201431,103100024002220,103303000112122,100003011021244,114003100020203,104210021140401,100112101024230,102042030211303,101000400301224,102010124001401], + 1401001002110320: [102104201320013,101023020301100,114220104000102,114004020010203,102100221341001,100011301000021,114310214033042,100100001040210,102014001441210,100203030110000], + 1014010333020004: [111410210001002,101023020301100,114220104000102,114000332302320,102100221341001,100011301000021,114310214033042,100100001040210,102014001441210,100013224103322], + 130224340411032: [114112124140000,110044220021000,102101231341022,101004004003140,102001020222140,112020300223020,103122411441211,114020014100200,102213040202212,114100010210310], + 212040400001401: [111120230020122,103100221440010,102140000212141,114301000000002,112124310203104,100113324103000,102424114020143,114012444020220,102001000221124,102023021321020], + 203000000000301: [112201000413102,114301000002344,100404040022004,101111131042000,100402030022312,100020301020010,110102021301220,102314341000123,101000000312021,101241201014000], + 300444011012130: [110241024242442,110444010032242,104132420010010,100001041031013,110300112023012,110224200113042,101000020301410,114000102210200,101041001032310,103100100100104], + 1001100100140000: [111124004101012,114103220220104,102120004001310,100410220030300,101021204000200,112141104020201,101200111020111,110001200422320,103210114021430,114223242332100], + 1200200200000002: [102332004110243,100000340100242,114003122300200,102000200123303,112223042043112,111340032200020,112012132300102,112402204011010,102301001101100,102042421123404], + 1031121000220130: [110100221223104,101022024010004,102102112002431,102412101112121,102404200230330,102110244000130,114000312301300,100102304302000,102400231404200,111113022242200], + 1401120004202331: [101221004014002,103100000124030,110100121304130,101421210300314,100014041001100,100400300013200,102232001124214,100030100030030,100000204310002,110122002210114], + 1401212021441101: [102143124001400,101204400304011,100020440122040,102002034010400,102020030220401,100040211031313,112010244000200,111100034100301,112404002023002,100033134104200], + 1014000124122034: [102030004002200,100040014210402,112414102011010,110014012001011,110022410420343,100100410401030,102000040222041,100400430022423,100201314104221,112323230202030], + 1010001022112102: [111020030040120,110002000134011,114301022320021,101122040304410,103344200113430,114101104102004,103030404010000,112100102012303,111302202204022,112003402002003], + 1002041020112200: [120032010212320,220103022224020,411001103222300,1002022230124020], + 1040003233111241: [114200212322001,100401210020002,100010111022102,100220300410430,101024201114010,102412220200003,110012222000144,100201214123301,114302122323101,103000104001003], + 1024330040310402: [101001040340004,101013004002011,112022334022101,101011324004222,101410401010030,103210241422022,103240001403000,102202204040220,102121010212140,110020124200230], + 122010220021224: [103000230120042,110111001300044,100101141042243,100101100022012,102001221100211,102100132000411,101240204233201,110320100402023,110220411214021,100110004332200], + 203021300200420: [100020310412200,111014124400030,100244420430210,110000200110230,111434000000313,101021344000412,101100101111040,111102200011210,110240312020042,100204420011023], + 1042101022144100: [102314220240000,114210034112304,100014201221340,100400000013012,100044240002100,110122200000100,110313204431110,110211042120021,111210200002411,102302210211000], + 1004203101302131: [102401030231212,114020012211143,100002110100031,100230112110132,114220414000323,100110404103132,102100010232001,100000324303120,102433214043112,100221200002204], + 1110401001202210: [102103222002012,114004322320200,100403220020024,102100244002003,103102100122414,100121034230014,112040200210223,112002142310023,100033010002203,100040101020201], + 1110322123410430: [112241020202432,103341411403412,114100130002210,100100001013001,112401002022010,103000214012340,100004204101200,102400134001010,102001004014032,101321040311120], + 1000133004321111: [104130301242304,114000124014210,110010104412000,100220100410211,112401002021204,100400300012210,114001132330140,101010204011004,102022024000010,110002112102110], + 1022130000421100: [103001111221030,111200020004203,104101201240100,102301112004021,110000011012202,100201230412211,101301000314000,111010002110212,111121022221002,102000020241101], + 1100300302202220: [114012044100020,110014012001001,114203204001211,112144220230212,101012300300123,100011114240200,112210104010231,102201241303232,110010002001202,100202101210043], + 1201320100000200: [110212022124220,100003100410042,100222034340301,101440044041401,111210012243010,102130124000000,100032310000111,102010421413322,102114020210302,100001100100040], + 131000422300201: [100440104303400,102122000214201,102024240221040,110320011200230,100342024100204,101422034042201,100011114300334,102303004110022,100110201042101,110134201140010], + 202001002404013: [112200431102021,111320124130040,110042234410000,102424111401024,102030200222404,114040340020333,101100240320232,101010204224010,103120011240001,103102420123201], + 1031004124140010: [110001202000001,111040304401000,100100120423101,100000040120302,100120000410100,100201004102032,111424002100100,102102041124313,101101231100421,112002030220120], + 1100101223222122: [100023101042010,102112310210202,102330010243440,114042044100403,114221224002403,100022410101442,103202014031021,110212424242341,100101014300100,100400242201410], + 1420420002431422: [101342300314204,114104200220022,110001244204302,102010244010000,103003204011330,114430412322343,114200034110031,100000430014301,114423002314000,114010134021022], + 1010322341002003: [111001440020003,102020204001132,110200020010003,102110004000221,111144202220301,114224204100310,102304011004310,102100144001112,120020201100121,102000041441002], + 140301140120320: [104210402020230,141401003011030,102331004110020,100002110402000,100033410001200,110024222100202,100040014202402,100020200000102,102222021110020,101001320201113], + 1000340024122141: [102001404012100,102340120222440,102122214131011,114223204100010,111041202200140,102100104000040,100023031000024,100020004101012,102402000201011,102311011000200], + 4020222202404120: [102040431121110,100400002201113,114111100021420,112024212301420,102212000200124,100300310140241,100240134323001,102111024000402,102042000222002,102001011100100], + 1012140134022034: [110302040102004,112110340200041,114000300001030,101220030300302,103233000101300,114020204100412,100013144302033,100002220412021,114120104002413,102111410210032], + 1431202004221002: [100442024301200,411231400122100,100003104342121,102000121100012,100400414321103,112130220202322,114320314031401,110404201113410,110302030412400,112003210211300], + 102410022421000: [110022004410312,102000401442010,321114010100340,100121041041101,102322101000200,101020041000102,110413131000201,112012002302100,102121321410143,100201120000000], + 134011101021021: [110101420400120,110110420012114,101210001032303,102103122004020,114021020011222,100040204304024,112001010231321,100304100140104,111102010032024,100213444314000], + 223020402022002: [100021200124422,100022211042104,114020132303131,102020014002022,100100204230423,100423202201102,110022120020002,100300421002040,103131000120022,102040004010020], + 1001311212012210: [114010332302001,114020400022001,102020220201140,110021021120041,110044410433321,102002221100222,112110022014320,114123100221401,100203310014042,112000221110010], + 240131120143301: [111121100010021,110310034424102,100100010422000,102101211410144,100024201030210,102010111102410,101000110322242,110100001014311,102404110230202,110043400012000], + 1121231100220222: [103324401401404,114411024141202,102203320200340,110233430000121,103003204021222,101010004213230,112014104000224,101001010301410,102300200210412,100010010400110], + 1000020010022134: [101020030332430,101022004214304,101010000323030,101001414212120,101001020322010,103310220113140,114200202330330,102114104001041,100022201043312,100000101031020], + 101012000310101: [110041030411301,103301210142043,100002024200142,101110044200100,102411000200000,100400014321101,114100122342002,112012020230301,100010101020023,110033041200104], + 122410102043310: [102003224011000,101113140334114,100101400000132,101221414041100,101110301040312,100030310422011,103011024000103,103041020101400,111300402200003,110000314200200], + 1422400440300103: [101400220300033,100012021032040,100012021040320,102130224023220,102100401143124,100010001030140,102110101410144,114142204121324,112102421102022,111320134133110], + 102034200403014: [110013202003320,110111032140220,100020010200022,100023101042010,102410111400002,102112310210202,102330010243440,111211010002130,111011002200232,114042044100403], + 1000002312230100: [102130020200000,100012101223021,100021004302202,100002040102100,110023330004130,100001104303411,114102010220042,100224204323201,102021301441201,103103144000200], + 1034103201030310: [101001040340004,102424204043100,112022334022101,101011324004222,100300211000020,101410401010030,103210241422022,103240001403000,102202204040220,102121010212140], + 1022030204204402: [112312122020210,110332000010101,110022331320122,110000030132210,114002004103231,100001004311313,101403030300132,102321021102143,103120121440000,103123204002120], + 1023000000003012: [100010424101430,114000224101044,102110022001111,101020301114001,102102300210103,103024011431131,101011324001431,102320200224120,100030014210012,114100300000120], + 1141100103113032: [110130314400100,100104010021241,100032431030100,102022004010240,102023211411003,102202031002304,102340200224222,114002014033200,100004301021110,101010124001000], + 1003222000202330: [102003224011000,112004310224204,102304420211002,110403042110030,100101400000132,101221414041100,100032424312011,101110301040312,102204010204023,100220000432400], + 1120211322100012: [100200400430003,114420102323300,110212022133311,110404122110112,110403010000304,114100040214000,101210021021243,100140024230240,112230240412241,101010200320244], + 1120000412044234: [102023210204300,100130101023140,100141314304233,110000004422320,100021304210300,100044304100100,101012341111024,103132204000234,112200002020013,100104010400030], + 1402400203042440: [110320311331332,112212030411210,111040032230210,110431201311021,114012244102003,114014200002210,100102004033300,102224300230021,101114120321220,110324001000140], + 102214021003000: [103302201400001,100021141223102,114323224031011,111000012222230,111303000013003,103131241240330,100220201001310,100000004342021,101222310302110,110200300012000], + 231001212202221: [102000004002101,101403014020203,100402004300002,100042030120422,101134224001001,102321234111310,101004010323441,110003032000041,103300234023033,110124044400220], + 102002010311110: [101224001202324,114233210000201,100002001024100,102103130221330,110000300140010,110011002100114,102011310202304,100002314204210,110010311210011,114004020020313], + 101133314002201: [102400111402142,100010000002400,141030301403400,100000024100211,103224200113121,110140101300004,103103221421013,120020211120020,110230010010142,112003000230111], + 1440322140010000: [110011110144000,114410024110002,114402014112002,140400400201014,100020000120134,121022000104032,102402040200201,111041212200040,110013004410001,100002244100310], + 100204022110010: [100304004104120,111101200022422,110221322120020,100013121221320,101100231113103,112030030214000,101210030300001,110021320433120,100101304232004,110221100001210], + 220101020000111: [111400124420002,110201400400024,101033124000402,102401000201121,111013232200403,102214104010210,102201100240444,101013411000000,102100001400004,114011402240010], + 110010021000203: [100014111040241,102201124020122,100020104312001,101140014001100,112202101103010,112001104002203,110030002000110,112000100212200,100220244121000,100140100414131], + 1002120400042400: [110012031011302,111200104411001,102121200313040,111011104401124,100300021202320,111201004131300,111311434120141,102224202023120,110334102021144,110421000003000], + 120001202103000: [102004021410041,102004044011020,114300014030310,110100001002000,114100202204020,101200321020210,102204014032200,100402240013020,111023420020320,103000000000220], + 100243230300201: [110102224201130,103301201402204,102401121113302,100021020124002,102104131412412,114020312300021,101320040302031,102400204043012,114010102300010,114042014014024], + 1131412411031024: [104103201240410,100300204010001,100011320043322,102204100232030,110110012110224,110000040041001,100103130412424,101210001020221,103100001242112,100200011220231], + 1400231200110312: [114020000030002,100233014224240,110110200001000,102221414000020,114121012340044,102000400240203,110004210004223,102302004110231,102203004032420,110000034212000], + 142301002100022: [103002104012101,114021000012031,122000430101030,114000022300301,100311000141022,114210202322020,114423024110004,102001101130200,100401301000011,124210120032121], + 130030002042032: [110220122044010,110042304412204,114020124021122,100002201003312,110110111010042,102230121120000,103300001402013,100400010013330,102204011110020,112111400203031], + 122220322000222: [102401021402212,102041020220100,114120204000410,100000001020000,104312001303013,114003104100012,114010214013020,112000224000141,102200414034330,114243312321003], + 1020414002422300: [102420300202421,102431104021200,114100004121100,114002004114040,112134220420402,102220030202124,101023221003021,100000311024240,103212014032110,102023024002104], + 1000113000240023: [103301210142043,112110340200041,100400014321101,112012020230301,100010101020023,114000300001030,102140101343110,102242000200420,101220030300302,100000011020021], + 1202024241242314: [110400200102102,111300040003300,102001410212441,102100034132002,100001430120120,121000000000100,122102300020200,110222034213101,101001130322442,101030400323000], + 1200040010022004: [120402022102021,110140101300004,102010002000402,110423221000200,110030211224203,114201402332241,114211030021301,210412232040000,114022000013011,120204020430010], + 1024024200112020: [101032141001121,101000321002030,100100310024040,103212010100200,132224022200202,100231004331011,100200010434042,123102041021330,114100444004011,102312201003210], + 1110211140441422: [102430401401200,101401000302120,100000020413120,114430014144403,101343421000022,114021424032110,112020002300103,102012021102214,111320122203243,111101004401023], + 224412020421420: [102103222002012,114004322320200,100403220020024,102100244002003,103102100122414,100121034230014,112040200210223,112002142310023,100033010002203,100040101020201], + 1122311101010222: [110201400400024,102112220202010,102214104010210,110042042120021,112010120231202,101011101032340,101013411000000,102100001400004,102310111000301,110032224422403], + 1402102400420321: [114101024120020,102004011440212,103140320213200,100000001021013,100011204300012,100001021221000,114003134011032,100101234330123,110024000432310,102012101443110], + 130002100302431: [114343002322014,100022314100104,114100022342130,114300010002100,100013024312024,111012002200101,102102211140013,110020220022010,110210020002243,110121220000022], + 111023012030222: [103100021421214,103312200112110,101000221031032,103402304003240,112402404024011,100332204310240,101112024024301,101231024010320,112001021122340,100340221201130], + 204002001022122: [111130224102101,102322020212020,114403304140021,100031131042030,112201422040000,114021040001000,114022300011000,114441124140100,114000002330112,102000314012111], + 1010342342312424: [100040020100400,110320311331332,110104010020022,110000300030110,110030010040441,112100300200332,101220030300042,112200211103401,103210310104102,101030004010100], + 130010200220202: [103000230120042,110111001300044,103210001422303,100101141042243,100101100022012,102020440242023,100220010002421,103222010114132,101240204233201,110320100402023], + 242002102122000: [102420300202421,102431104021200,114120004000010,102002001130001,102404000230201,114100004121100,114002004114040,112134220420402,102142100210120,101023221003021], + 1022000310012100: [100442030020022,110210004400002,102012011131100,100112101040103,110304220401302,111303042200110,100104004030002,101002210342202,112034100230011,101100111114011], + 1040020040200113: [110020010134221,100004020411020,100300321000010,100000421021322,112331012023100,100021010100320,101001030303000,110031210000110,100431024301030,101222321204303], + 1001201004041200: [101140130013320,100204210031132,100023001042200,103224034003141,114202022320120,110442122023340,110020240400120,101022044001032,103101404000040,100110100033144], + 1010041103400010: [112410300200000,101022420321103,110224102034030,100412210430201,102002004012101,102002114004030,100400000012403,101020231020220,101414220303014,111001214403102], + 1010241221130203: [103204301402123,103102224034002,111100100004430,110102111204210,100041014102004,102000000222203,100301101000021,110020140044140,101001301032024,201120000130201], + 1102222220310100: [110203131211112,114103412201420,110014300041302,110010022003021,110020310022021,101121021020012,110321001330010,100000300100000,111240304101330,100420010030240], + 241104000033302: [114101004121020,100040301042132,101021104212100,102102241341004,102323404112032,114312012320120,100000041020230,102041021121210,100031000101440,103313300113232], + 103142012230024: [111240220002100,110030344201413,101001014001021,110100001014311,102304244110431,100103224301304,114000100020200,102100322001021,102102100231000,102122000221020], + 1440402013020100: [110121200003300,111040104401311,110102031222030,104101041240101,102400304041032,103121004000420,100040311024300,114110020212130,102002102043132,110041300410101], + 130010001011042: [110040022130003,101120014204000,110014300001402,100100014230110,110201004241002,110130201000333,101000131142230,103042100100430,100104044230000,114022024012213], + 1142312313100034: [102120002000022,110201420003020,100011304210101,112200011102100,100010210104123,111130102210101,103121021443212,103021401244424,100001040102000,100100001001024], + 223201221310101: [100020121020300,111110010022310,103432001210300,112440134041000,100210240013000,110401214242400,101044214042221,100033201031241,110010114210202,102141000313022], + 120300024001004: [101421000300000,100004000004212,102020424011001,110210000123320,101043130321113,101120100020310,100400420013021,101212040300120,101410441011302,112100124020213], + 311023222001200: [100000431020101,100244100032320,110010212101240,104104001243020,100032040000331,104124102100301,110002010440412,110111420033313,103100200103020,102000410200403], + 302320110211040: [114400034122341,101444024041143,114121002310100,100001101023021,102020032000000,114002004033124,103204321414213,111120010020104,101100120332004,102100230210011], + 1103100044011014: [102121221343020,101400010303002,112104424022201,100013211002142,130030220200012,112200110000221,1300034431310021,144020001004041,1001010233020100,112012200120020], + 1004012200023020: [110202004211120,110341010044330,102031144010424,111021030042411,100302420120212,111212114131222,102140001441301,111012030022123,110031424214112,100001230120013], + 142404301142103: [114031022302044,114103020221100,102010244010000,114430412322343,100000430014301,114010134021022,114102224104002,100040240003341,114422404110312,112140134003231], + 1101330100342343: [102002014000220,102203004042010,114004014011110,102410004024030,114402320000202,114014112302234,102012401001012,111230040010002,114112000004001,101004421020002], + 142100121003020: [100000044301222,111012034402110,114221004034110,101223041020020,100011230120014,101104024002242,110133120011001,100400010013033,110100000031102,100100001043001], + 1113010140143422: [114020000030002,114031000022030,100201211003004,102014002000401,103103241421322,110110200001000,114121012340044,102000400240203,102104304023201,103310300140324], + 100311220124023: [110200400000020,100324140141402,100002204340200,110000410001034,103102224034002,110020041310021,110001001200323,110102111204210,103013100120001,102000000222203], + 1041041203210240: [110001332120300,102101211411000,110003000420200,110243234240200,110004014411012,112000120232022,102041220200010,100002320113100,112240200202201,110020321120011], + 113200100201203: [110300000402020,100014401210011,102323304112140,100004401212000,100003034100001,102000010200014,102110402004000,114030100040000,100002024212102,101000040343001], + 1112002131011030: [100002011042020,102010200221000,101041201002422,112000002000420,114201224110141,114002004012300,112431004013030,114144100031004,114424014110200,114420022314022], + 1012100002403103: [102401030231212,114020012211143,100002110100031,100230112110132,114220414000323,100110404103132,102100010232001,100000324303120,102433214043112,100221200002204], + 1001001200023002: [110114001202122,111021202200011,100001010100220,114110004102301,114002114012041,100414031001210,102000004012011,114023102303000,110101100012002,114421002320003], + 124114120100202: [110130302012020,102000100222110,100000211021004,102411134020204,114032200030021,102000000224012,110210120000001,101000120303020,102000001133312,102202220200320], + 200200104122033: [101001000322303,103120004002000,100021441032202,100031000422032,102404120202300,100001304100000,103022041401232,100213114342042,100212001002030,102123000200142], + 112223200442400: [102110112001242], + 124000111321230: [110144240011020,101040211000300,110413401240204,112000244001222,114441114123013,103220211421421,114000012334102,101000014012442,100312401002102,111022210021013], + 1101003400210121: [100303230141010,100010421034201,101000110310443,114100202341000,110203111302200,103012100000024], + 242214323420220: [114040102210432,100034004211240,102140121410131,101201340300430,112040200233002,101241100301411,102113111343110,114020214123240,114002220010031,100001010412000], + 1200430010000411: [101000040341000,100001024102000,111330004130112,110000042002101,100403440010040,100202210431000,100003020422102,102320100212010,100111324230343,100200000011200], + 1024200000322340: [111030302201103,101002330300234,100440134301011,110000211010231,110402402020420,111142142101013,103143031442112,101110104002011,102204204030403,102004001410212], + 202002000244020: [102121124130314,112032400230000,100042010200121,101022220302103,111010200000412,114200002320110,103013241240202,112010000243420,103032214000202,114233200002044], + 1101310100043441: [100112000402300,100101220021240,102220011122100,110122000020202,100001001034141,102040244041000,101404441100012,111120140021303,111020102204112,110421002110030], + 120000431112110: [102101211411000,112032040234431,110010232004000,101020004000000,100102224033421,100120040400011,100400110020244,102021001411110,110041102012100,114222010213042], + 200431043110310: [114300022300010,102011424013030,100420014301302,102201102000000,103012240110400,103012220110230,100120421004010,102012021101230,112220430200204,103121404002104], + 1020300131241022: [110020301220324,100041000010302,102020100243032,100031001020040,102012200202303,101110404021211,103110041442122,114210400000112,114042014102321,112003110242131], + 120041020012002: [110222020012300,114244120001041,102120111142201,110010011212411,110102322040111,102002104011244,103230010114302,110010220000210,114010304010030,102140001402011], + 123003220030300: [110222020012300,111012104400010,114244120001041,100021140000322,110010011212411,100300020142022,103230010114302,114010304010030,114100202200202,102140001402011], + 100230403201114: [110030002000422,100011004343022,110401140004202,110040002034100,102402330230011,110432242020141,102110334020204,103200001420012,112002002000344,102120020230022], + 124400200400010: [103020031403100,114003104031111,102302331003300,102320000221020,102120141343312,100012020410120,114201022330011,114020420030200,100120400410300,100100310024321], + 104301422204142: [101022040322021,102042100242012,102144201402040,102100201400021,101113031012041,110030441223002,110100122212220,100420011010004,100021420122102,110000200023244], + 1010103211230204: [112110001104000,100102200021002,112002020220002,100010204013120,100010221221003,100110144032230,101000000310112,102201202022411,101020021031103,112141122310440], + 1110032200001010: [100312331004000,103301244010210,100101031041022,100000240003101,100032224101400,114110004002200,102311110222320,101021410320100,102301000241011,103001220100000], + 1111200112112311: [102204001121032,102004000220013,114003124010140,101000030322212,103000200112220,110101422010012,100120120112100], + 200430313010320: [110443010102111,114303120004402,100444004302301,111320004131241,102020101324002,100210031004220,101030224211010,102304321002412,114140304122040,114404130030010], + 1002002040230401: [114201010001201,100030024300201,100040300102020,102400110230001,102101011342100,102311210240013,101312211000200,100312131204422,100012230204000,110143101120300], + 112024240000100: [110110011340130,100210304330211,111121210031101,101041010324010,102104210214401,100011230101432,100032024240322,103202224024200,114400044140001,114120010000040], + 1112201420040040: [100121110032440,101030011141012,102200100232031,114221100213120,102211104033011,103210000102210,101142444001020,111420144421030,100031004202000,112012042001200], + 1002100102031003: [103103231424020,112203400410130,103232044020212,110300410040034,112000042312030,100013311220103,102101000310001,102100221124440,114203004000200,102103004001021], + 120201022314002: [110120144200000,114022412330004,101200221022044,100103104302044,101041030320401,110241112020204,100002004104004,102100104002224,102100224000210,102020004000014], + 120202030214112: [114004142244000,102140001441301,102002004012310,110000011220204,111200024102040,102103204000000,111301010002100,100020024100000,100021204341100,104133130010123], + 122402201402242: [102203004042010,111244302220204,101114000332010,114001032300011,100142044103021,114004014011110,102410004024030,101100010012423,103102211440104,100330020141212], + 110022210020204: [104100002100221,104310001300102,112000044002102,114021132202032,112012004004324,103001314001021,103040024041111,100110101040020,431300131230002,101004004213014], + 203220122341110: [102102101412200,103003000142012,1002201014202430,100112430012432,103330400114023,102403004020222,100002301031043,100040321042021,100302224314022,1211200224022400], + 1130000101424000: [101001400301113,103101024004200,100002120200101,103300021402104,102014111102023,102100431342023,102102024000001,101012044004042,112410300200001,102020304000321], + 1100000432221010: [100012001023022,102112012004120,111112242211204,100000041201200,110021410130302,102003340204010,110003004420010,100030201031300,100012401022403,100042431211020], + 1001002421332411: [100012320001320,102000331120104,100232214222204,110203111111000,112104212010101,100001104201201,102300221002020,100002101020010,112010202000202,102033024010010], + 1421022122020102: [100111211021233,110100201140241,112001022300000,100203210003004,100042204102400,112120124020214,111304442220340,110003001024303,110032001122110,101000044001103], + 100121200242200: [100000111000003,112400104044001,114423002313230,103201021402002,100304101200101,100203310430032,100201130410420,112010214003000,100404220013411,111102020010300], + 302200041100140: [110202000000310,110000010120043,102102011413000,102403404004110,102122410220401,110301311303102,102141410230020,110103111120042,114420000001301,101012410301010], + 1202002010204401: [102011214000304,110100104403201,102202000200010,102214204040420,112340020203003,102443011400041,100010430022021,101011001031001,111300030040030,101010001000231], + 201230032030022: [110320202023400,114101420030202,100011004343022,110104422010121,110302204433321,110401140004202,102402330230011,110022202130021,110142432042212,110203210002230], + 120030000000120: [101043042401310,104001222102120,101113012101010,110010102002310,100021220002020,110023132100402,112112410232001,103004041414132,102022102010211,110231202040203], + 1001230142004120: [111312000000403,102312010211010,111011242233002,100000011041021,110014210424201,100100141044110,114313200211321,102001114010033,101430020300303,111321010040420], + 122210123102100: [100000020004101,110130014400011,110232002101410,110200021210212,110131021240303,103100101442233,100000031220100,111010000021300,114200444140203,100000124211001], + 1010012300010214: [102041310200042,111333104124202,101000304014100,111431110000042,100040011023101,110301030010140,102004441124110,103303201400021,114101420030202,101123232010002], + 302104300100113: [100000410103200,100001240410410,101042201000011,102030001412241,101001204010220,100004301023143,114223200221140,101012400304201,100031044300340,112004021121002], + 1420111102101004: [102131104023111,102420130230104,103000004010400,100000004310002,101000004003224,100012114210011,111200304131014,100000340120221,114133104120204,102001340200322], + 100021000020012: [100000220100001,100122230031414,210303212040010,100000014200104,102440024021100,103231014021201,114000232300122,100203304122231,100122111002401,102000101120014], + 1440211140400210: [111134204102000,100400122201240,101000034000203,110422200000213,101020031000300,112044200243000,110000400000233,100202140430012,110000420020100,112000112030300], + 1020110310300200: [110102401201204,102400100230000,100212030414010,102031021441200,101200020303202,102020041321410,111340300010010,102013224003020,100002210201212,103013020123142], + 1102030214000300: [100010101030000,112020112300102,102140040210040,114010000021104,102431010203240,114113004140010,114004000040100,100010004203102,103202300102400,114103200002100], + 113034310204312: [102224101113104,100312331004000,103301244010210,100101031041022,100000240003101,102311110222320,100040310123023,103001220100000,114124420032020,112012012002100], + 131401244102202: [102001000212142,114121000002140,100002214100100,102120104003011,102120402000014,102000200210032,114020002303212,102303110220130,102223231121242,102103132002023], + 1100113332434120: [111030212113431,102001111011201,110044320441241,102233034000002,110410122010102,101122404022022,110311110410340,112101202012010,114240004000000,102300104110220], + 100101040000421: [102130020200000,101104020300301,100021004302202,100002040102100,110023330004130,100001104303411,114102010220042,100224204323201,102021301441201,100024040122220], + 134014011004200: [100113220020101,114031000022030,102014002000401,103103241421322,100300211000020,102104304023201,103310300140324,100002224244002,114310200002400,103211220100010], + 1042320131012320: [110441140102024,101004120224442,100413311002132,100320421001431,101233021020010,110210301200101,111131102210013,110400241240242,101001024210000,102210101121104], + 1032310024101130: [100013100100014,100120234300003,102100014000422,114010422330121,110020402100200,101401424024210,103044001403210,111300122200243,100000101040410,111222222244101], + 210140102011040: [120001021014002,102021204013000,110424200100400,100423110021010,101224110302431,100220110000201,102123024003202,102010011124143,102201040200403,114040022210401], + 1004314020004310: [114030110041300,103112004030003,103100311424002,103040224000100,103132424000410,114323010000311,100400220013232,110010002000100], + 244120023102030: [102300324010203,102100142002204,110113004402201,110301232000100,114110340004414,102104020202131,101412010334000,102020100213212,110021141213001,102332001001302], + 204310020011420: [110400022010030,100214121000000,100042034200032,102011041100210,114323000000130,101400240300010,102412241111002,100424104302020,101013234000010,103210014003000], + 214013043012111: [100423004302232,110030220000310,100110034332223,101223100300200,102001034002201,101104401020410,102032031440302,100113004304010,101310311000124,111303214132004], + 112001020320102: [110011001021000,111120002211010,101201200310001,102020000201200,111232000010230,101230000302304,102300211000020,110222100011043,101020320323422,102122004000004], + 102413100214132: [100240000032004,110221204243141,102000000210211,111010204401023,103142444002002,101200010300001,102211300204221,114420232314210,100301004321221,110312300040010], + 244013143230120: [101020024212042,100041204212120,102113110210240,112423424042102,100320431000002,411200101402221,100120214230002,102440100200000,103204200103440,100210004104001], + 133004040301010: [111000242201231,110320024430030,102040101121143,100002210000020,114311040000110,100000014312111,112003130224002,103404004000103,102000020220103,101002410300300], + 131100330042222: [100022041001002,111240340004003,102021024000010,111101222244030,114032424122040,112011012004300,101021401003220,102000401120420,100301020420101,100022024100041], + 1020300040010001: [110000002200001,100201024102012,110000324200322,100402002200020,111340104131020,110114132013304,100121324030101,110010431320002,100010034301040,110030001010000], + 1140431400240421: [103012004011310,111003230041302,112400010203210,110111022044102,100300004104143,100002224104130,101010410340000,111020210043121,100120010402000,101101201114100], + 101204202102111: [100310304310342,110140044401202,101300124221002,100010041031020,100042400001023,112402000200101,100020201221000,101010020301243,102030001103000,100040021031201], + 1434102314324032: [111302020010000,101300221003002,100000121020303,110200220010220,110020004203240,100020010420242,100100204232000,110031020114222,112001410232200,102012001132133], + 1111040032001420: [100000220100001,100122230031414,210303212040010,100000014200104,114011120024030,100101121010100,103002011240201,102440024021100,103231014021201,110110420034120], + 302123011110002: [102011201101012,102300304110030,114412000003141,114120430002002,103020041420212,100112011040011,114033300041020,101201220300012,100401024300321,100000100120300], + 1030012041401021: [100101021020221,100121014300312,111144004103013,111000002221010,100012431020010,110220442220001,101010000332203,110210142123042,110110400003300,101000201143043], + 120000030100401: [101030001001022,110230231300100,102010424000101,100300121000420,100402431014100,100100001220400,110330200400021,102100020210143,100030024303110,101423100300002], + 1410012140000222: [102101210213220,1001013211040100,101404203243201,1132012124324031], + 1003101201201020: [101200011020000,101202001022000,114012222301110,100031224102002,102001024011010,103042141420430,100000424201223,100002120011102,102112004132100,100101021012040], + 201210023004123: [100002024201011,102004410220430,103013411431022,100344101004202,103044004012014,101040004222021,101002114000000,102400004020303,100402200031004,114340400001040], + 100000200000321: [110014010012200,100400142200030,112233010221200,114020020001014,102442400231201,102120304001402,100024004103100,102224000214240,100141014231104,101201104042203], + 1000204112132210: [102004414000212,102010221411043,102003214013022,111100010023012,111020240024110,100002101021040,114013324102022,103102324002110,100100100021142,114212100023341], + 1021040410444201: [100220034323210,112121212300101,100001124102222,100400100022003,100032001041230,114420002322000,100141120014242,101200034044300,102204044042410,100020310010001], + 120100042004144: [101230011020001,110000201222422], + 122004111402000: [102111030204323,100010410021300,100033101030010,101133300043021,100344000422241,102113024003300,100010030420033,114302424032232,103410031210320,103222021204312], + 1100110210000310: [114101024120020,102004011440212,103140320213200,100000001021013,100011204300012,100001021221000,114003134011032,100101234330123,110024000432310,102012101443110], + 111010121010402: [102442024024214,100443211002141,102100330211131,100011014103012,100030220101040,101130031041024,101240021020011,100400020033003,100100110411000,112204130410100], + 100004110033110: [100310014310311,100400000031312,103230004000142,100400010013000,102011114000042,114110024003013,114142102344042,114114040001042,100000030003111,103002004001434], + 131411411011001: [100100100412204,103120210100100,101424100304000,114004000022042,103003444010014,112022000242003,100012241220110,110002111042010,112420122022130,110002321321021], + 1214321220001300: [100422000031421,110302040102004,101402114042420,102220021120430,111341300012200,100102000010243,112410034040040,111302304130401,100024334203210,103031410122401], + 1420123210040202: [101200341010102,100004000102302,112011300223041,102200100241120,102030031133201,100240101000210,122011112200413,100000221233001,102142034004000,100030201021200], + 1022320020001020: [100121230031032,112000431120410,103042024040104,102304104110001,102000200200301,100104211044110,114241222321321,114021002302020,102313204114304,114013124030022], + 240234000100141: [102112204000101,100004210400203,100142414232131,100400002200000,102100100214030,112213100200230,100002221022420,100122104020004,111031104110300,110431100000020], + 100011012042204: [100114004100001,102012030213014,102003320200411,102002024000132,112440114040203,100401001011010,103001204002010,100340114211043,100033001220020,101100120334014], + 111030220140030: [102140411342420,103243024040441,110021014412440,102020004000301,101031101024100,112000210242204,114403014112210,100100224031000,103111001212300,110010112102022], + 132022104422222: [101004010304203,114104204002313,114300000002130,121200013012000,102122210230200,103110411212041,110421410100301,110244400212004,114410104141020,101002021110410], + 130010341202000: [102422114040010,102020004001311,100101101010100,114103212312012,102321044112101,100022024100041,114231212342200,100020011043020,100021231020200,112022200202104], + 101010213000232: [103301244010210,100101031041022,100041234101100,103001220100000,103210004031201,111231012242301,103240404032240,114444004140210,114114100214000,100011121022401], + 1434300020030411: [114033300040100,112021201120101,114202002320113,101000104002203,102010231120312,102300014110023,102430001401230,114420302320210,102103422004103,101000011111400], + 1040301200000100: [100040300102020,100012230204000,110143101120300,101101200311102,112401402023020,103142104001331,100200204123011,103031120143010,100103401003022,100101130101111], + 110413230020140: [110124010031144,110311312000001,100140010411214,110010320023302,100002120100314,112004431132202,114130202311020,102111031342214,110103022012204,100214200004002], + 1130101200220000: [110101124221101,101421000301032,102121122000024,102301004113010,101004004003140,114000312331020,110002002104100,102301214110003,102222102020220,132400144402210], + 1001000200002422: [100400400033012,110412321240412,101201020300000,100200444320120,112020204001002,100120200402000,100102030022032,100404340013222,100111200031001,100400002200140], + 1031041330034004: [101010241003223,100000201041300,101100300302102,114011200003102,101020104000040,114120420223002,114012402332300,102302020212101,100030004104210,103030201434002], + 1012224102421104: [114000044020204,103044010120003,102320000221020,110142020400012,100142011022211,114230344103210,100030020104423,100102011010000,100000001021041,102000000212122], + 1041121202302432: [110301011234204,114211102321011,102110221412210,103330421400224,102112042004203,102000200201422,100032204200023,100120431012000,112210204002124,102003014001002], + 1012010004022204: [120001021014002,102021204013000,110424200100400,100423110021010,101224110302431,100220110000201,102123024003202,102010011124143,102201040200403,114040022210401], + 112120100132301: [102211230244321,112121214040022,100004004100120,100041014210020,100000030100102,102140200224200,101012400320002,112002100233204,101001244010120,102200121300400], + 100001030022104: [102010200221000,101041201002422,114201224110141,114002004012300,112431004013030,114144100031004,114424014110200,100014030200221,114420022314022,102322001000202], + 121003123220221: [110130314400100,111121100010021,110310034424102,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442], + 200040101004123: [114201102320021,102010124004041,102011021132412,101012004212201,114000102202022,102442100201100,102222421012100,100000400120232,112001410240333,102310001003111], + 1000121020042000: [100000044204004,101020224210014,114202244101041,112423102010012,102112022001414,101212214011134,100001121023210,100012101020002,101424010301210,114204120000200], + 1100002120012100: [102014002000001,100004210100003,102431121110021,102320004111024,100144301040241,100020024342004,112031401123023,101442041011111,101101034200101,102111010310232], + 1040230030200114: [110400332010004,110132222014033,110300310011000,101020320320424,100014121020424,102110111122212,110313010000400,111002022220000,114202220210010,110030011010043], + 133200422110231: [100000020004101,110130014400011,110232002101410,110200021210212,110131021240303,103100101442233,100000031220100,111010000021300,114200444140203,100000124211001], + 110001211000201: [100201114323042,102102011341002,102141024001000,114222144114122,103001000102220,102021010243000,121100311033233,103102044004203,111110202240200,100002000412000], + 1001212300011100: [102110230210000,101124201110410,101423221010210,100100224303300,112240002024221,100040420200010,114421302322203,102011204010242,101123010330203,101420111010123], + 101134003411022: [100014011034234,102240221000001,100000324303120,100221200002204,114000024101102,100101011013002,103002121432200,102141101410101,440203203132211,102012011104110], + 111010412400020: [110001022000001,110023342101220,100021004310222,110020422131120,100001000100000,112220322030220,110202222043022,110313312021120,100220214333200,110330234422000], + 1014200020002102: [100411024300421,114210204001422,102101001412002,102200000240220,114010302301200,110100242212103,102013014000124,102030100214200,114204140213040,110003320121201], + 130202300120020: [102422114040010,101204400304011,100020440122040,100301020420101,114103212312012,102002202000000,102002034010400,102020030220401,114231212342200,112022200202104], + 314100040210102: [100000201020000,102030024112031,102401011401222,100002002212000,102114341341012,111420200002021,111001224121320,104042022102100,104030002100140,103421124042304], + 100311100100112: [114212420211103,111200042221400,100342011201332,112224042022101,101222104020403,111022014110000,111004424400103,101012124044012], + 212004331010240: [102422114040010,100022041001002,114032424122040,102020004001311,100101101010100,100301020420101,114103212312012,102321044112101,102002202000000,100022024100041], + 1102201000100020: [114020000030002,114031000022030,100201211003004,102014002000401,103103241421322,114121012340044,102000400240203,102104304023201,103310300140324,100002224244002], + 141000201201400: [102040431121110,100400002201113,114111100021420,112024212301420,100300310140241,100240134323001,102111024000402,114321002320001,102042000222002,102001011100100], + 1102120044000042: [100000044240301,101140021101302,111120224100101,114440120000030,101023041001203,100201021001300,100211400140102,102323110212100,101010040320111,114300014030021], + 1012024020222240: [111102110012000,111142010020301,100031201030331,100000144104100,101000344010212,101033141030001,100104400021023,102111210230204,101003400322022,102200421003014], + 242401011120420: [103303001404000,114024312202242,100020001011422,100110411200024,114020000022214,111240020000201,102221204020110,100103121021000,102203204123112,102302010212201], + 1404002001100411: [100422040021304,102000024011300,100021320123031,100014041042003,100002010413410,101011210300000,101433010300204,102114321401000,100002414201103,101002221140440], + 1030042010204412: [111003110010202,100104000024404,112100404022020,110110011140012,102332041000321,220132443001240,102330211001013,100002301221010,100000324201220,101041420322222], + 1031314220400013: [112241020202432,103341411403412,114100130002210,100100001013001,112401002022010,103000214012340,100004204101200,102400134001010,102001004014032,101321040311120], + 1431000000000041: [112102024020402,114400202314210,102102010214442,103022110142241,101002024000400,102101211410144,102240231110222,102010214000120,114023142202040,102330020242041], + 1120004301122440: [102401030231212,114020012211143,100002110100031,100230112110132,114220414000323,100110404103132,102100010232001,100000324303120,102433214043112,100221200002204], + 101313100310010: [111400124420002,110020402002000,101033124000402,102401000201121,100112044024030,101202024231020,114100042311200,101010001000400,102201100240444,100103100414402], + 1430340000422012: [103303001404000,111111000014001,100020001011422,101023321000020,102010221132220,100110411200024,114020000022214,103113204001423,102221204020110,100103121021000], + 1141030001430141: [111130224102101,114201000004122,102201024041200,101223301020130,102322020212020,102144002001240,114403304140021,102103021340120,114100024004214,100031131042030], + 112301040212242: [101020210300204,100112020023021,112203122042414,101020214003103,103021210110121,110203100002414,114002100002414,101211011023023,103020224040304,101143031140312], + 1100001423232033: [114102210220100,114001210033034,111221102222020,102102010211012,100230220410213,110210002100320,102100220220023,101111211012031,101213110301020,100100210414012], + 1240203113110303: [110202012100020,102303010241010,111342020011220,100314114322101,102230130203001,102021401324232,111222102243400,101004410311232,101201034010420,111220410010144], + 132201100020001: [112102024020402,102102010214442,101002024000400,102101211410144,102010214000120,102010111102410,101000110322242,102404110230202,100010020101222,101222104010140], + 143000200040430: [110444144241024,102001101130120,1000310103100002,102242301122200,101240010310200,110040230120420,100200020431202,100021430021301,102011110213001,114001002300400], + 1022011320030121: [100004214100234,103000011400001,110402410002000,102001011442200,100324200110130,100342120144000,102020001440011,100100031003220,100200034020100,100000041021200], + 1011222301013300: [110022004410312,102000401442010,102000014004040,321114010100340,100121041041101,102322101000200,101020041000102,110413131000201,112012002302100,102121321410143], + 1100040020240044: [114213002340022,102120140212001,114400210002021,100000021022400,144200203310100,1003022312322100,102001244001224,114030214020000,102023422000000,114213004000003], + 104011311014010: [102300401000244,101043004000042,100042034212023,100001404100302,101101014004001,102112220204201,101022020303401,111322022222202,110011114201210,102000021121130], + 132044004300421: [102430030200201,120142100101000,101202321024330,141202030000322,141200042321141,103110340030100,101044004010300,120120221230400,132141134410102,1003102040011030], + 100221120044210: [102431111110001,102323101101400,1003002030122040,202003402402323,101230330042220,1320124301012211,410142111403201], + 1101120114012022: [100020400410010,101211210304010,102010041122220,110314422023002,102100001004041,110000403400000,100000414104102,100001020044101,410310420012412,101000020100020], + 110010213034220: [102033021130021,102001241410312,100000121042240,114000332303001,102330021000131,112041031114021,110400240002411,114432422322332,114044240023401,111004002202111], + 1024342412040111: [101041310301004,110021122100000,114431224113420,114033012202420,111211002241330,102420001400320,102012000213011,112040004000012,112012032002220,112410214043412], + 120102320201223: [110411044221200,114200222340000,112024232302040,102423031402210,102322121000002,101012040320004,102000011410132,102321230240434,102140014000102,112000020220201], + 100200222011104: [110021040020010,100001140020000,111011030004021,100012101223021,100121104300201,101220330300003,110132000024420,100224204323201,102021301441201,103103144000200], + 1004020102010020: [401142101000022,400114001102410,102100000012031,431232000323104,1012100023110102,232023302143031,120200122422404,1020220210340010,111414004440203,1040100003200241], + 1003031240200000: [111041004113300,102020010203200,100011144312020,103110120210013,100020221040231,1012220402104110,102011204001010,103012004034001,102001410221023,101010111034000], + 133120230041403: [102140001441301,110302100111410,102111400210040,110010220121014,114000402300001,100020024100000,102142022001203,104133130010123,102010420212022,114132200222003], + 1111242014404013: [103412204020401,100014410420202,103304100141001,110201324240244,112002014003103,102012040232301,100402002200121,102442100200132,110202114242400,101003041032000], + 100004312224000: [111330120000213,101011014010102,110000100423033,111222004100001,110222002034040,103144001420031,103101130124033,101231400300040,100220114121101,100112204301144], + 1032140002100120: [102001404012100,102302200210010,102340120222440,114223204100010,111041202200140,111300400002313,111101040014040,100023014313010,114021040010311,100002301021040], + 1112030040102000: [100041204212120,102113110210240,112423424042102,100320431000002,411200101402221,100210301004023,1302011220000002,100401430030420,1300302112030020,100140221202112], + 123132013103013: [101203004040100,100142224230113,102104131122031,102320024020040,101100000320132,110402122111020,103040120000040,112010000211002,111041012143402,112130224021002], + 1100421422310024: [112024232302040,100040131021101,102322121000002,102000011410132,102321230240434,102140014000102,114020100042040,102020304012040,102144012001120,100400004100332], + 1010200334204000: [103100130122100,102340011104001,112300002022101,100430101012411,110112320021204,103411014002010,132000110000001,110302130004200,101000000300110,102112100210100], + 130002304011003: [100202400434310,100000010002202,114410024140040,111221024440402,100021344104342,101011121032013,110000300444443,100131310002422,101000024014331,100203021000012], + 1031040014131300: [102401030231212,114020012211143,100002110100031,100230112110132,114220414000323,100110404103132,102100010232001,102433214043112,100221200002204,112001030021004], + 120302002100002: [102401030231212,114020012211143,100014011034234,100002110100031,100230112110132,100110404103132,102100010232001,100000324303120,102433214043112,100221200002204], + 141004440010111: [114200212322001,100401210020002,100010111022102,100220300410430,101024201114010,102412220200003,110012222000144,100201214123301,114302122323101,103000104001003], + 1020102000020042: [112001001112001,100310444310004,112332000411020,102431200203321,100211001204102,110002400042003,100000004244400,102032010241003,110024001211221,102403204000000], + 300011200341000: [110013202003320,101031241000010,102120231343224,110030332100203,114404232310120,103100034001310,114002202210331,100031301020100,110111032140220,100020010200022], + 1001342410002023: [103101224000011,102200042000104,103002000104400,103002144042123,110114021000012,102304204110040,112020004002110,114242210004001,110031404200110,114033020020202], + 101133210200002: [114112124140000,110044220021000,110122400401032,114310000004320,100000324340102,114443200000122,102440020200020,103122411441211,114102004002022,103414020133020], + 111301210424031: [112002204004403,103013001430040,100402021000101,100100220024041,103030200142241,103010040123432,100003001040112,102112322004011,102334101001210,111203430002211], + 100430210211101: [102224420201000,103013034012221,110302311302101,100000120002200], + 1102402400440041: [112113214020100,103300344012201,102010202004402,100000130013400,103224041400220,100001321032243,102104244000010,101001010300404,100201104224131,103340004020422], + 123202224112002: [110113022011200,114010024033002,101201001024132,1042411340004022], + 102312020044410: [101004120224442,100413311002132,100320421001431,101233021020010,110210301200101,111131102210013,110400241240242,101001024210000,102000324010303,110023102103200], + 1220140112400113: [100322014312444,103010110100111,100120410111230,102022024010214,101030004002122,103232004020011,112013110224020,100000424310110,111114332113210,113030342402110], + 120022011130410: [111103240020200,110022201100020,100141214304000,101430001012430,100011204100020,102410220200004,102100211340043,103443104001332,112100311104022], + 1011304420320000: [101230002122040,101210241204043,104102040011120,100123011004113,100420001002101,114103220220104,102120004001310,102430121110340,102020121102120,112141104020201], + 1002422010322203: [102001201440040,100212000030034,102300001100112,100121010400103,100121111001223,110201030101402,101000120300010,110324304424130,100002024310012,114431000001000], + 1202000011001142: [100000044300303,100002030101101,103300220111112,103141324004100,104120021242040,114300024031112,114102002310230,102211124110220,100400102201000,102100100220002], + 144313310001020: [100131031020002,102031401100332,114003222201103,114120212310000,100022204300000,112012211120102,100101040400110,102203111103200,111000000001211,100404200013104], + 1032002104103100: [100002100100210,102420424042020,100010001032223,102111024000402,114321002320001,103020031403100,102200401111200,102000430221040,114003104031111,100100000422320], + 130220011132020: [102114321402233,114310430002402,103202320100322,110300420102224,110242444432002,110021100022013,100244144101141,103000104032321,101023440300102,110140110023004], + 1440231030110030: [102023324010020,114000004103003,111131002212014,102110100233222,102120311402124,103140124002022,101042421021120,114013204013220,102000100221400,114241204001213], + 104220402140410: [102102031320011,100041140201301,102140041342420,102140021410400,103011100120201,100000120202410,102300004110122,102202334040220,101001100320224,114000202300004], + 1102400401230211: [110002220002220,114300022300010,102011424013030,100420014301302,103012220110230,100120421004010,102012021101230,112121404020102,101000000300323,112220430200204], + 1020220231131000: [101121211101004,101114101012020,101001304001101,103000110142041,102002112041034,102041111020030,110022001201023,112401144042000,112200124010030,110422010000000], + 110020211102034: [102121240200000,114001232300102,102323324112410,101130314020142,101422210301101,103000041402003,100000104102100,100043044210031,114212344000432,100001021003113], + 120010142301020: [102401030231212,114020012211143,100002110100031,100230112110132,114220414000323,100110404103132,102100010232001,102433214043112,100221200002204,112001030021004], + 1021101401020232: [110101200032041,113402202420020,100000012212010,110041002000220,100040111030202,101142410330304,103110001242101,103431011210021,111132304100420,110433222223310], + 1420013100302320: [114003122300200,102000200123303,114402212311130,112012132300102,114020310024000,112022010222000,103401431210002,103313141402020,100001204200000,101013010320220], + 210230103011000: [102000004002101,110202000000310,100422314300200,101403014020203,102141410230020,100042030120422,101134224001001,110020001224021,112100000200031,110003032000041], + 210000234010131: [102040431121110,114111100021420,112024212301420,102212000200124,100300310140241,100240134323001,102042000222002,102001011100100,114402104142102,100030010102102], + 1202310030214131: [102020314012030,102020224000000,101242101020042,100002104104001,102421010200213,114021040001000,114110000002010,102301141002223,102110300210002,100001000202200], + 311022002001000: [100422040021304,111111000014001,100021320123031,100014041042003,100002010413410,103100204000400,101433010300204,102114321401000,100002414201103,101002221140440], + 130101000212042: [100032041021210,110004301222000,102040011121100,114310000001232,111202012222402,111322234130000,102040041320010,103203401400132,110104002010100,102042204000300], + 130111410421030: [102400014042200,100422201002310,114403120002242,100021020021013,114020002203014,100000204203120,102401004042103,100024030000243,100101301041100,100003104300220], + 120314200012210: [112020104001300,112400104042431,101400110300032,110032412204130,111242402020001,100101004300200,114101012201420,111032414402324,102424040202123,102110024001402], + 1402011002010022: [100024234201100,100010234114300,100331200141014,130000420243230,110112204224100,102212234021233,110224102230230,100120411200320,100100341202102], + 1100402200221321: [101204004040140,100022102100243,241221402002000,1030200104020421,1000102021230333,110344021203140,102200310230230,103001134002100,4002244101001011,112020002001230], + 1040124103000020: [114222040214020,110200004210000,100142221012003,100100030402001,100121221022103,101000041142321,102120124004020,114101204004022,100120221222104,111440404400230], + 100200002340002: [100400000020210,114011300040140,110240032042222,110200022124020,102234341124302,100024110002203,112024414000023,100000104200120,110210200014413,100020134102010], + 1022144210100043: [114031022302044,114422004110130,102012030213014,102003320200411,102002024000132,112440114040203,100401001011010,102021221120401,110100331003020,101114000330410], + 300440311014202: [103401000120223], + 324212220100003: [110430341310122,100400100020024,100020211223400,101102241114000,110014142204101,100203321004410,104130230010032,100100011220404,110010000020002,101210001313401], + 212001013010204: [100002024201011,102004410220430,103013411431022,100344101004202,103044004012014,101040004222021,101002114000000,102400004020303,100402200031004,114340400001040], + 1011031002141401: [100222000004100,110002001222210,103122204002112,102120000202211,101103320301203,102011001102101,100402020013010,110003004212001,110310430012302,110041002120211], + 101044041410200: [110012220442042,100034204311021,101121024024120,103011131430040,112201104011200,100201244122014,103020420121211,101020041033003,100003221024211,111031030040220], + 1010123243314001: [102002301120010,201301011030444,100012034312220,110001000020034,102004014000430,110140332002220,114111240032010,100431240001030,102101024002121,110014024202014], + 140202003024042: [114022412330004,101041030320401,101203121020430,103130021444021,102100104002224,102100224000210,102020004000014,102100200210002,102031001411010,101400004022210], + 1004010001102003: [104244002023000,120133001040211,111320124130040,110000110000231,100142041012023,110000000411120,110302100010342,101301030313022,111440222100012,100420111002101], + 1043212000021040: [102000034011002,103204000110000,100001014340021,114203202330210,102103001340022,110214110004122,112032000211000,102300121000111,112021020220112,114100102202223], + 200014212120104: [101011400320030,114000004022410,102410012002102,101000134010220,112330302020202,112003042310200,102220001120020,100040000003122,112024140222012,114014022301200], + 222201003101000: [101002120301230,110010000411100,100400020022110,101030411030220,102111310313001,100123410022301,100001014301120,114023044020211,100001400404002,110401214221203], + 1401232020042113: [110322104424202,101202421002031,102102220312102,103004204021310,110012310020200,102030130241300,100232224340041,112400002011010,112011001113222,102240134031142], + 1411140200001240: [100000324342000,100000410412010,114412124141222,103300400140000,114002304101321,111002202221023,112002144000001,101240010300343,101010411112210,102340410242300], + 103412011010020: [100443120030100,103032411100001,114104002340200,100020114210041,103214331421023,102120141142220,100221421002211,110040030000044,102100030222020,120400000024121], + 1014024004102004: [1020102021344321,101030301001232,100104302001300,1001102321230101,220200021120010,140320413003120,400014401213001,1020423021001303,100021204230002,320143400144303], + 1001022111231200: [100214000430410,101100210320232], + 122100210311210: [100102000010243,103000300120001,112300042020334,110001212010040,112112122012022,103012200100120,110402000100440,100011110200210,110210101210300,100013024213130], + 1101124221301400: [100021000104004,100002200022012,111140204103210,140004010302423,114200320003120,100200113201000,141220400002200,100044231103400,100411033204412,110000001210210], + 1224144040212102: [110000204210130,103102104000031,110201134243240,100100100422103,110020134410001,111100044100001,102204004042041,102101002004300,102043001021033,101210211022100], + 101000001100200: [102420424042020,100010001032223,102111024000402,114321002320001,103220011411101,102001011100100,102200401111200,102311120222404,102000430221040,114003104031111], + 1004030002312130: [100002100100210,102420424042020,100010001032223,114321002320001,103020031403100,102200401111200,102000430221040,114003104031111,100100000422320,100102020411200], + 120103422003102: [102421012023000,114203412342202,102000021442024,101000410340001,103000000122004,101210024012220,114311204000403,102100001340121,100120211000004,101012014000204], + 110021314000002: [110311331003000,101020240300003,112021334001000,100144430411240,111000024401300,102321040213311,111210442211022,103222041413120,102103010312411,110433011310111], + 100110000242233: [102334004110232,112200102024122,103000034003300,112300032000100,101000100322140,114010010002314,101120030010320,114124002341030,110302322102041,101300004231010], + 1000120001110423: [101400004022210,102031021441200,102300031004340,102312301104422,101200020303202,100000411002023,102303200241200,102140202001100,100022200121301,111423014422320], + 1023040204100410: [102020204001132,120020201100121,111122012213410,142011110011130,120320000422011,110024000413122,100022200410202,102021201320102,100420231010003,144041310003010], + 110110202031302: [110002010000240,110124010031144,100140010411214,110010320023302,100002120100314,112004431132202,102111031342214,110103022012204,100214200004002,100400030013021], + 1144332120022040: [100240414222323,100210004030410,102304004110020,100003104302021,114342024030024,102021201440011,102202030200124,114132104004011,102103200312030,102000001101130], + 132202400004130: [110110011340130,100210304330211,111121210031101,101041010324010,102104210214401,100011230101432,100032024240322,103202224024200,114140404123402,102130031410200], + 1100230304230004: [100004300000204,121202234011000,102124021023300,114001014102403,112444304040204,122022100000222,103121420214211,100003024211200,114302402321024,100000020120210], + 230001222111000: [100002131024210,102410001402210,110000102100012,102010020223010,102120214001422,101412300302220,110320002024021,114201200004112,114002044114140,101400201100022], + 1021002001040202: [110103002040200,101220111020012,100000214101311,100004024202000,102112430210103,110310004424040,103000114012224,100033131043244,103000024040413,111102002220124], + 1040000013000201: [112222002021104,100221304220024,110121112012011,101400401012014,100213001002313,110020100004110,110200310002240,100211024101002,103140404001201,112100122300333], + 121232000414130: [102030211324014,101040344004000,103014201410032,100111211000011,103402210131312,102200132000032,114230324000001,111001030000002,110000204214122,110004000020130], + 1031040012210001: [100033114200011,102201130200131,112002024004122,100410040030230,112120110200240,100004120402124,111201002200020,100012020420232,100000101222004,103412114001210], + 1001200101223001: [103034031400131,103322000112244,111123412214002,114200220003001,100043121024120,100001011022100,100240110002411,103410000104330,100104104302020,100021201012224], + 1100020200001102: [112113214020100,100000130013400,103224041400220,100001321032243,102104244000010,101001010300404,103113010102100,102211430202033,100110301022230,100320114314042], + 1000101020041032: [101000024004442,101031104002100,101101230331040,121104330112000], + 1120020430031021: [202013001110004,101200020302200,1320010210001300,100010230021300,112012111114213,102230004030112,100100221012100,1002022012411300,112102000202302,103013200104400], + 120401401002412: [101213114040141,102210101002412,111140100011101,103220120212134,114200014001032,100344101004202,111103314101000,114140104122430,101100010302233,102021241324040], + 1100100220100210: [111214100000104,102103034004032,100430221011100,110422010000200,103112021442033,110044014410012,110030231214100,111121012243322,110100144404220,110004001040434], + 1002042422001100: [101300000310241,103103001442303,100031000410300,110001302002012,101020414001023,102110411023111,100102234100211,100010204103214,101000024000234,114104120220001], + 142120223030024: [101010201030113,114012012300010,111202024134001,100302000140001,101000004003224,111302120011012,100002314210021,103101031440430,102021014004211,100000211030342], + 1010004003121400: [102422114040010,101204400304011,114032424122040,102020004001311,100101101010100,100301020420101,114103212312012,102321044112101,100022024100041,102020030220401], + 1121201240200221: [110021000410432,103202000110102,102020440220202,101010010320112,100042000000000,112000021122010,100021111043012,102122101023020,110124041140000,103300021402104], + 134202004322020: [114210410000401,103210214003143,112210010201431,100024104100032,103100024002220,103303000112122,100021304103002,101120024021024,100003011021244,114003100020203], + 104041224043122: [100442404301421,112400012012002,110000002132011,110200442121020,100121221022000,103220110100100,114200124144010,100302220420400,111401202210212,103133001240012], + 200330200011013: [102242010244123,102023200241300,100400130010102,112000132030001,110000032130121,100202000000010,103131001210231,110200131311400,112101112300110,102100201143032], + 1001041000301243: [110134200122322,110200412020210], + 101302203404011: [110024021040134,110000310134014,114000012334010,114302200002200,102001201443121,100200024301301,101120000011032,102111002004022,103210031422000,102211211000203], + 201241022044100: [100034114100102,110330002104200,114000000030300,110011111104432,102000221034000,102143421000420,100300000441223,110201012040210,110000321104200,100104041000002], + 1012413000110222: [102101004000411,102434121112224,100024001040202,101200210300413,103210021401223,111110014101210,102000004001141,100002211032042,111344032200432,102100301341002], + 220201201130122: [110010022130210,110401304243400,102321101000300,102104100232130,102403241400023,102010020210100,100000404210104,102104211400330,101130024000302,100210310002000], + 1010042010300014: [102202310203222,100042001020203,102002320220202,114130210231020,100004410120102,111222214101043,101011211003002,101001040304214,103230430101003,103013144020404], + 1042210002212232: [101434200303301,102302100241110,114000224021230,102120031340220,102002244014003,102101120213444,100121044230340,114031442303000,102010214000002,101412101103402], + 211134301000322: [102041310200042,111333104124202,101000304014100,100040011023101,110301030010140,104100002101431,101123232010002,114421242204443,110100222001100,101010001002000], + 114000010022010: [102041310200042,110320202023400,111431110000042,110301030010140,104100002101431,103303201400021,114101420030202,114421242204443,110100222001100,110302204433321], + 304410134022101: [110034300021014,101042401000112,114400112314022,103004104003011,114014010043112,100112440013034,100041001211002,114200134110042,102002201413004,100033020104222], + 100121400000120: [101221422120021,103001024002110,100231114320100,100001000002210,100004130002301,101210300302302,110100012120201,102020131413423,110020204200342,100000220011133], + 120204001004324: [102322014113341,101022104001221,100040201012040,110021422000000,101120030330110,112021004003303,110331012224112,114100222310230,101002200301130,100011120000004], + 1021234200200340: [102120214131012,114130312310220,101411010300100,111120114103002,100004100102242,101221101020012,100101210412030,102334110242204,103210000102000,103123321444000], + 1133110010022414: [110102401201204,103020200141000,102400100230000,102414034040100,100212030414010,114011200003102,100412200002013,114312004002020,102020041321410,111340300010010], + 120212142112100: [110120144200000,114022412330004,101200221022044,100103104302044,110241112020204,100002004104004,102020004000014,100014204201000,102103321411004,100400001001300], + 1000010241040420: [100024210002210,100000020121140,110200000112123,103022204000200,110241020002103,102023021100010,100221020410103,101120241102203,100010304340120,110020010120340], + 1122100002424110: [100410410002011,102101224002210,110311232120010,122203322100011,110330022021224,100410311001021,110123442011041,103021000110211,102201324110204,103010141222231], + 100210303240020: [100000110410000,100001004104043,114022212300211,102104241412020,101200000304000,112014402034232,102102104002322,101003011000111,102000000211031,114200340003213], + 111212300242140: [101001044211204,100031034311401,100023210021210,102100104000203,102000200200301,110200101200402,100000140100020,102021201410011,114013124030022,103211014030010], + 1011220024120202: [102242240202112,100102424230122,100241100430021,101040101001202,100022001231022,101010304000212,101010010320220,112000002000103,110010040002340,142112232110201], + 204010012101140: [114313304002310,112204010411101,103211010211331], + 212010120203212: [110201201211024,100032201024101,111124004101012,114103220220104,102120004001310,100040341020133,111101344104210,100410220030300,101021204000200,101200111020111], + 101040003402034: [102102000233342,102001140210301,103302220110131,110100111121002], + 220430220011124: [104100002100221,104310001300102,101200011020000,112000044002102,114021132202032,112012004004324,103001314001021,111300220000230,114110032343001,103040024041111], + 1123240110202022: [1300422220310121,120032010212320,1023422111011102,411001103222300,1220101103414143,320440200013001], + 1401430311300300: [103202004001120,100120204003012,110202102121400,200304020022101,114114004000121,102022034012314,1300022002310414], + 101313042403213: [114020000020001,1302101004142102,110001001100001,201014000241421,110400102312140,1043303323011400,1002000010441103,140011220320300,114200022340011,401400200400300], + 300213220001120: [110101231202300,100130444102110,100001204342232,114132202313300,110223310000311,103010304012101,102210044010110,112000404000001,112000001121002,103103124000111], + 200300020003100: [110222020012300,100100100422103,114244120001041,102120111142201,100021140000322,110010011212411,100300020142022,110102322040111,103230010114302,114010304010030], + 100100000002201: [102001001110120,110221220004222,102020020222311,102412300200000,100400430022230,100010200100020,102141200210120,100101414300001,103001004014140,112320020200312], + 1043002220010141: [102300221002020,103120000104021,100124221021011,114012002304110,100031200001240,101200140304140,102302234020012,102102010211012,102000110221004,101002330311011], + 1004300000012431: [102030410223003,140400400201014,102422001400000,100301224310100,101020220323012,112101102012030,111201122241213,100002244100310,114022302300000,100143110421000], + 133210000000041: [110033000022043,110100200030100,110430430003002,104412212102010,114102024123030,100432200033101,110132020031210,102340211000200,100020200102220,114420230000240], + 240231110100012: [100313030142202,114122220031004,101221020300020,100121021011022,102013401100100,1132202011200221,112210102030020,102043030202102,114230024111000,100402120031033], + 1040210003221001: [100003041020000,103100401443440,110030420441114,101002024212040,114110200004041,101000404001000,110210002031212,100000304102201,101010010321410,101213001014122], + 1000122100102041: [102302144110440,102143202000400,111130224102101,114201000004122,100143034304100,102201024041200,101223301020130,100041004200042,100341044310403,102144002001240], + 1141323022303011: [101032141001121,101000321002030,102000144014000,102100104002302,103212010100200,132224022200202,100231004331011,100200010434042,123102041021330,114100444004011], + 1414013020102000: [101301014221122,114220040000201,100404400013222,110012130410040,100104101200201,111040100020010,112201010203210,100000214310412,103042320101230,100120430411222], + 1101031321234320: [100040301042132,102102241341004,103031000121000,103002020101431,102020300220201,102020431101132,101404104000404,100012104210032,114213102324020,1041210023400124], + 1011020001000032: [100023404242000,110033101044200,110204002123041,110002404210000,102300011004443,114102122200241,100201021001300,100022240120042,110212001204000,102224210203004], + 122100120012032: [114221312340014,102434121112224,100311204312442,100001024100241,103000020100131,101211204201231,111130412210000,100011300412123,102000004001141,100000110100200], + 1002140033020201: [110200422121211,114100004121100,102212014011000,101002110310112,102110304003102,110321010102000,100030004211002,100000311024240,100002041020000,102420010202004], + 1404010111303430: [101221020011201,112310132020030,111200210001023,101101401020424,114030220011120,100011101011002,112002110240403,100100101220114,100002210000020,112410110201010], + 102310010204343: [102021100220120,101222041041012,100032124210042,103222000100010,100100000021020,131213314114102,110020000000320,114010024020443,114021112203200,111302002221301], + 1142013310040202: [101020204002030,114034220041220,102102231400111,114000204101231,100000400412200,111100232241200,100001020121021,102111024004010,103343010113030,114040202214201], + 140404211020143: [102012201321104,101021004000000,101002011001110,103012301401041,100022130100210,101001301000011,100001020002400,101200034044124,103042224001110,111000230041031], + 1042212201001312: [101400114040043,110230222121001], + 1002011012031132: [102001000201100,112002024000000,101101300010120,100030214100100,101021104001210,102120334002020,101401000302000,101041204000012,100402200013100,110034210424200], + 1010010040010131: [103220214030401,101000021034110,110401404221420,102120310322101,114012344100300,101023000300100,102130020224110,100311010422310,100010424104142,100400230022020], + 121200103210000: [114040300043111,110203111111000,114010030024204,102010201012014,102041204000002,102323204112320,100402201004014,100420404320101,102123414032304,112401014040034], + 114022314112413: [114311204002010,100002101021120,102102012003220,102313114114000,114004102201202,100000101001431,101043024000300,100001044241012,102030420223110,102120200201042], + 101002310004220: [101233330041031,111121024400002,101102041114021,112202020200200,112003414002222,101330104221320,110143012013241,111103322224400,102343044111203,101220141202202], + 102042104210410: [110130302212044,103240010131114,114020312240022,110302241332230,114110200001300,110210011300123,110402220003241,110103100400230,111121134100001,102410134022300], + 201120034040002: [101200011020000,112000044002102,102230021122000,100031224102002,102001024011010,103042141420430,102214001432020,101011420323313,102002104000111,114023024022000], + 223210010231010: [111121210031101,112312022021021,101200101021000,102104210214401,103000024014022,114120010000040,101040000302000,103100120114020,102320310224141,102000404002002], + 1403220001132200: [100242430032003,101412131010213,102020010200102,102202010204130,100032000002120,110022030110040,100424011014010,100042000010010,100003040422420,102000331132232], + 1002100404013021: [101222321200012,103211144033404,103103240104001,100204104322122,100041301021020,102100011341012,100102001301220,114130000220023,102314224010213,100000120000202], + 320321101040100: [102101324130010,101440004042202,114040020021023,111230114102201,114201102342110,101400300300111,102122302000300,100100204101010,114101200210030,102114020210202], + 112003000100240: [102301344113012,102141124004222,102430201110000,114010200020312,112144220201011,100002131020410,112042422001032,100111200414020,102443421400110,114044414023030], + 1100030101300000: [103000004012003,114000014014332,114040002210003,101401304040214,114441402310144,110430002023100,101002311031133,110021144413041,102000004014112,100200234220021], + 1102223032103021: [102120012001031,102323304112342,110430320104000,110020221320103,110121111202231,110240020100212,110012001214430,110004431040201,113204011001300,114221002340120], + 100124140040100: [102044104002014,114021004011100,102140140310001,102022000220004,110210001310230,102110111023103,100010144303000,100102434300310,100421200001003,114024200040223], + 131421101020101: [110000411313130,110400000001201,110000010430211,110001212130303,100103301002044,101221311022241,110100231202400,110020102102000,100000201022030,100402021012201], + 121321102023020: [1304031410000002,103224040221400], + 1110002210110203: [102112432004423,102402124022000,102032204000102,100200200412034,102101230310000,103004041410020,103444024001001,101004004211001,101002000323021,110200202231210], + 1103413200201012: [102404341113402,100140310020221,102033442000014,101214400304203,101200004010120,101204044010203,112014030203304,100123200410410,102100440231020,112023230230101], + 1000021020100134: [102000001132113,100042001020203,102002320220202,100120010421220,100000201041300,114011200003102,101020104000040,102432101112141,114412142320040,102100044000000], + 122030231324002: [110042011204212,111024024121404,100340001000212,110201102030430,110211011302040,100121301013301,100214011004010,100032400104331,101240004040032,100202024104300], + 1002004034001120: [103002100100101,110000402000040,101000220301403,110300124420043,100212104030201,102400401401031,102201400231110,100213024220000,110003102131421,100403214302001], + 210011030010110: [104100002100221,102000321102310,112000044002102,102134044134410,101202001022000,111300220000230,114110032343001,100110101040020,114012222301110,103120440104110], + 1020020000302000: [110000012103121,110212201200033,114010234012413,100400310020430,100011040023100,110120134222021,102214214042032,100021234211320,102301404020000,101000204001132], + 1002033200220220: [111332210000301,101404201014234,110231010421003,114100024002412,102321300210040,110022204200044,101031001020043,100103404234443,100402401011232,100400030022000], + 1123002404100003: [111403414421302,100402021012201,100010201230130,100011201220110,110020014200010,102110020310200,100401200012030,102010111134043,110000014202022,110302030400400], + 132312040000244: [112300002023320,114210032320402,114100002340230,101030200300110,111000114112131,110110412014004,114102100212002,111004220022422,114201012324201,111100202241010], + 241020023100311: [110330400010040,100101231004020,111000100012002,110022140120012,100143040411011,102404404004104,114002202302000,100034000000002,100400100031022,110020130044232], + 1241130110010004: [110203022120020,104121030021030,114303000000120,100402200020301,102132204003422,100203321001203,110000210041101,110133022014110,110121311241021,110210020001042], + 1002030101334100: [111101002241322,100000000120200,102132424020001,103100121423010,101004304210104,102120044002231,103003044004000,114010144020122,100002404210001,101102020333110], + 1112201202020001: [100024040001400,100400322200003,100222141002002,101113000331203,110032101100411,100240241002011,112203124013030,100212100430302,100400412200020,102114044000001], + 1420244240403402: [100004221022001,112210212031100,100102444032011,101120314000210,103222010102041,110034140040012,114401112200031,112420102013241,110001011322420,103021124040242], + 104004210012100: [100214000430410,101100210320232,102302001102032,110003004412202,100100311001010,102010401101200], + 134021010101103: [110100001200320,100000214101311,100004024202000,102200230202120,114200020003000,102112430210103,110310004424040,100033131043244,103000024040413,100000034344404], + 1400031030000100: [110132010032031,100200044102003,100110231000142,102420210200041,101312004211100,110010030101400,100432200431112,111022114120310,114003422242201,113331432424011], + 1043400020013011: [102230010201400,112011014020221,100112101011130,112310022020213], + 1023121200024200: [412310220104121,114100222340120,132011000122003,120100010104132,110230010002303,103002020001300,1002203202101123,1304043431201120,423203002400042,1302321010020120], + 100010311030114: [220103022224020,1304100402114410,1022200104230030,410142111403201,1002022230124020], + 111100000211210: [111012104400010,114244120001041,110010011212411,100300020142022,103230010114302,101210211022100,114100202200202,112000020210140,102200230240322,102012100200002], + 1110403002011121: [102144201343034,112132120202010,110002201320001,100430010431044,111020122230001,103040201222041,110111221000100,102341131103201,110000022003020,103104014002131], + 1040101220404002: [102400010200011,101413321300222,100031004101000,1211200120132310,114200224001003,102201201002010,114310224030143,144203403221310,103304201400304,100011040202101], + 1020014030200300: [100430221011100,100112434101120,103140301441302,114001302300110,101010000330233,112101210200001,101221104013002,111000014110023,110010232000300,111224122220314], + 202030001001024: [101000041031301,100020424214024,111221212223401,103214400131240], + 243243313212003: [114021010023030,103422000104202], + 114323030201000: [100310120141002,100004001021111,103022021431010,100003000104203,102041410242244,102101220214011,114000424102300,102120231343021,102311110240101,102141020210132], + 1412022410102421: [100243401002310,100004000100101,102020030220200,110031404423144,114130104001000,110014114201012,101004000304012,100022210410130,114034424104042,101002000323022], + 1200132241010202: [111323002200100,100021044202120,112401000200410,102202210201312,102212444022430,111020012111214,102010002002034,103220021410020,100020104312240,114442120000403], + 311022132121010: [100002100100210,100010001032223,103020031403100,102200401111200,102000430221040,114003104031111,114000044020204,100102020411200,114200302341234,103002110100200], + 241023012214002: [110011414240022,111142010020301,102100104000040,112132434020310,100000144104100,102124031023100,114002104020100,114200024110134,103340114022112,101014014000004], + 1401402042441110: [100000100120300,114202244112111,114011404103142,100202121000302,111000142201220,114040002300000,102002430222010,100101041011230,102323001001000,103004021432210], + 303004103010002: [103011200100000,100302000140222,102122340200200,114000214021240,111111000020023,111344032200432,102400220203010,111000000012202,112012112300040,110024000410240], + 111100213001110: [103132001240124,111040000020020,101042100313010,101120200320322,110021102200021,110210041300110,114104300212311,103200110103041,103110201240231,111430220001210], + 220020022113412: [110011000022102,103021220104200,100021020104220,102202410240103,102120001343001,100112004101222,114202332330220,100030001041404,103043011400000,102100021410201], + 1102301322130333: [102011214000304,102202000200010,100042010200121,103032441431121,103013241240202,101010001000231,102340031103401,103101010110042,103032214000202,114233200002044], + 1002122223002012: [102420130230104,103000004010400,102040404010111,100000004310002,101021014224121,111301000000031,111200304131014,103020200123211,100000340120221,100400130013000], + 121000221103203: [102203344011410,100021324100000,100002020410020,102103430210003,100012014300120,110100120400020,102414014022212,102012220241003,111120214102000,103130020213032], + 1422304411001140: [102040001134000,103003410102200,102212010202013,111144202224001], + 1120123022114210: [102420104002001,102020204010103,112202100203012,114000002201211,102230004011304,100020340212010,102000420200000,102442144021224,112211022133400,100221441000130], + 130031010200020: [101002021020030,100242134100332,114401100001322,110422040001042,103101020110000,110220042123040,103414101210300,111221310002240,102241011101100,111140020012204], + 1001410030220011: [102310120240000,111020022204020,110010002002213,110303100010101,103444110124002,120202001100101,121300000224002,103000124021132,101322301000230,110101020120003], + 1011001010330300: [101233330041031,100013104102120,110412221244140,101102041114021,112202020200200,1022201020410210,112003414002222,110200241201421,110010114411020,110143012013241], + 100410103221410: [110020301220324,100041000010302,102020100243032,100031001020040,100104001041200,102012200202303,101110404021211,103110041442122,114210400000112,114042014102321], + 143422000001200: [102310324112030,100410130030232,103220101421001,121110020100002,140004230143221,144200400000000,103321202010002,101124344200400,102021220202100,102024410220121], + 111210020241120: [100133024330243,112002011133010,102343000224400,110014320024200,102141000212220,100010024101122,101021020320214,100001024240340,103001321240031,133321004220020], + 1240200340101120: [101010424210144,102202000201220,102203011120021,101000424210014,102103122004211,103022230124332,114002002300222,101010334004200,103003040102120,102420041111041], + 100212204303222: [102001000212142,114121000002140,110123042010000,102430321112030,111113004102021,102223231121242,102103132002023,100024121030022,100000020001022,111141224102220], + 221243210101020: [102200211120103,100231411002211,114132040223044,100404202200223,111202000003000,110232400010300,100131201202420,100220111000200,101043021124401,100003010000000], + 210412002030120: [102110202001010,114420200000104,100043200102020,103332044032320,111222000012010,114142014124243,100000004100411,114022344022303,102110004102101,102332201000140], + 102010210420110: [102011201101012,102300304110030,114412000003141,100112011040011,114033300041020,101201220300012,100102030423010,102101004022104,101432240300300,101232104042101], + 1010322120400002: [110034012104202,102300444113103,110402002023040,102443120230311,100411031000011,102012000241430,100032111220130,101201111024014,102010014000110,110220004211001], + 1100120000002214: [101004120224442,104120221240413,100413311002132,114000320043340,111100030030120,100320421001431,100024004304130,101233021020010,110320002020403,100202024123224], + 1021330002000231: [102320021000100,114010024011000,103212100100000,112341421131200,142100000024013,112404232010231,114300402320043,102101120211200,103110214004242,114021014023400], + 1041201011130001: [110242002110210,101001331003101,100310424310200,103040011223003,100110411012240,100040214340010,100230221001300,103000004014020,102003400200101,112121104024000], + 1440014233002010: [100112434101120,103140301441302,114001302300110,101010000330233,112101210200001,101221104013002,111000014110023,110010232000300,114102322200110,111104120022010], + 1000304011012020: [101044400340202,100012034342242,114101422201430,111014314400310,100212210430040,114020000010101,103121041440100,112140010234021,101100004000012,111130010032011], + 111114002000400: [111120230020122,114301000000002,112124310203104,100113324103000,102001000221124,114123420002142,102023021321020,114040204014042,100040401020413,112414334044310], + 111021140144110: [112302112020021,112010032340022,114120304000212,114111202313213,101042041021001,100010031232443,101211414040000,100012404203210,102104401140012,112000022310414], + 111101142002300: [104411012102030,113012100130004,110000024200142,134230121002024,120300120422200,110300140101200,113112420100020], + 1003003202220022: [112002110220340,102002220221002,114100234004010,100030410102000,112240334012440,102101010210022,100010031222001,110020200001031,103001114001210,100034021034000], + 120002022031230: [114211010000210,100003040101420,101440004020212,110100201000100,100001024102310,100000004210012,102112000204313,111111024404430,102213204110020,100224120001302], + 1004130300301200: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 1023024011003011: [102023211411003,102340200224222,103212000212121,100100011010220,114114414122002,112002010220004,114320110001030,103211014000111,112120340203021,101243010302200], + 1104442324000210: [112113214020100,103300344012201,100000130013400,103224041400220,100001321032243,100201104224131,103113010102100,102211430202033,101031321022412,102203001300000], + 1224402130201431: [100020344302010,100002100000100,114100102340003,100100414230101,110130030020000,111214004444320], + 1010220131102102: [102442024024214,100443211002141,102100330211131,100011014103012,100030220101040,101130031041024,101240021020011,100400020033003,100100110411000,112204130410100], + 1143002030000011: [112202000411103,114003344011001,101203001010111,114003022300020,100031201030102,114201104114111,101041001003300,100001100411302,101414214021020,102320231001040], + 140010100100004: [110021104200001,100302141003012,102004441124110,100000301221024,101224322120022,114100200002120,110310020040401,110200010014000,110202204430020,100002024303323], + 103101200204302: [103242420100012,110224044242243,101400004022112,100100210000011,102200000200201,103110020210000,111343012200000,102201430201310,100022141030334,103200211410311], + 1000001110121331: [110020301320101,114013212300032,114001034010131,110401041140300,103000121403344,103310041402103,101122101102100,102202001120002,110200010003201,100412041011012], + 112411111044121: [100422040021304,100002010413410,101011210300000,101433010300204,101002221140440,102040021424212,110324444424432,100100001010020,101000000322000,100102021220030], + 201012302100201: [103102300102243,110000000003200,111202004100121,114031000012100,100222220001202,110200000004322,110020014410200,114004204010100,100410041002320,111110020000001], + 244020110002440: [114343002322014,100022314100104,102130314131401,114100022342130,114300010002100,100013024312024,102002020243020,114002002300201,111012002200101,102102211140013], + 141000010030000: [1300004001031100], + 1002311410242000: [100300031003200,102310031100100,114002034102120,101020200302021,102230121123030,114020402303041,103000000104034,103020031420410,100002021020001,102322014112302], + 102121322420121: [102014001130210,110002302201420,102421004041011,102240040202421,100130004300103,103000404000100,100040004331010,101203001022300,112142441100101,112420030202242], + 1203001320140430: [103220011411101,101030404212000,114220014111304,101030301000221,102003111413120,100023101043203,114200122340300,102013024002300,100301321200402,114020420030200], + 1403400402043211: [112221002043330,103214200103130,101011024213031,112222042030004,102230200204114,114241010002120,100224010430102,112100202301420,101210021000110,101000121021044], + 1104224330341002: [110212122030010,100010014313003,110210000001240,100220001211020,110203200013020,101423441010401,110432100401100,100200010434122,111101202242012,114213114002001], + 211200002112414: [102000420203042,102000211443214,100024000000132,102422331113042,102100231341003,110011124203230,114003324014400,101001204000121,102202210230122,101102014003322], + 200101214201100: [110232011000001,100130004033423,102111301413000,101002120323040,111000212203022,112200422011002,114120122340141,112401112300120,111021202201210,112243004012113], + 1101021200302101: [102041310200042,110301030010140,104100002101431,110221000111302,114101420030202,114421242204443,110100222001100,101010001002000,102030020224102,110022202130021], + 1041122130040112: [110002010000240,101000014004010,101102041020024,100140010411214,112323000202020,110222004210002,101204431000204,100002120100314,101112001100201,100400032200040], + 204111111020021: [102040431121110,114111100021420,112024212301420,102212000200124,100300310140241,100240134323001,102042000222002,102001011100100,114402104142102,100030010102102], + 111033222130304: [110020111312122,112400100203303,102102310234432,111300232201020,100201110002411,100000224104030,100120121023011,114110340221112,101310124231042,102412034022002], + 1021410140403021: [100030400013321,111100044403012,100001111000202,102032001030043,102311114111000,100310010102400,102044144002103,111020210000113,103014020140401,114200404111202], + 310301002202020: [111110034423202,112014440221201,101022004002300,102311010213330,100021024310204,100022104100032,102001024002022,101003004212410,101000004214010,114440122312030], + 1002100044014100: [100003021033300,100011011020440,102110020202330,100001010014420,101011001103200,114001214100103,101200004040021,114023314013200,102040104000040,114022120040112], + 114320230201000: [101030001001022,110230231300100,100114230020141,100300121000420,100100001220400,102100020210143,100030024303110,100142120100230,101423100300002,103111300102020], + 1401012200230100: [102440011414040,114121002310033,102122014003000,100020004100000,110201222031001,102140001444011,112040212002200,100332204310240,112001021122340,102010134000100], + 1010021032030420: [100121200020000,102412004000132,110000002133140,101233341022410,103013314020203,100102401010230,101030021031101,100122124100132,100100124100031,103010201402134], + 200021212200003: [102201124020122,100103034003113,101020301142101,100130120400120,112401030203302,110212000400101,112003420210300,114202000000002,112000100212200,100140100414131], + 140430210140011: [101004321143032,110002210041204,101110100330302,112021412003113,111012044400414,110044322010013,101000024002220,111022040000100,110012041100001,114240322320222], + 1042200323442110: [103011424002021,111202112220003,101002401020122,102220242000201,111010304402110,112114030224400,100131101022241,101132010320401,111100132103413,112000040241000], + 1424020112010201: [100240000140032,101042104010000,114000122301411,104122202100000,102111002001230,111102010020434,100400204302004,110410000002004,102200210200442,100414231011020], + 1420022302000340: [101221004042212,100303111000101,100202000430000,103101041210203,110400040000210,101230420300200,112004000213042,114240010000030,110113030403241,110022002001023], + 1000102010040402: [100113444000011,112001144000032,101101400332443,121402220120031,100340040422001,112241020200031,122220022201102,102240100200224,122220002200110,130002111021012], + 1441132222010024: [110101124221101,103300014023010,101421000301032,102121122000024,102301004113010,101004004003140,114020014100200,102320214110001,114411004143412,114000312331020], + 1400010220131004: [111102110012000,100031201030331,101000344010212,102100431342023,101033141030001,100104400021023,100131400100220,100010000101133,112400020200004,103122101440000], + 131043220000000: [102104321001201,103210010100224,110002240040003,100400040010302,102004224011140,111400220003310,110000241321331,100204230432012,112040012001112,103433244002210], + 342401020011140: [110311002102104,100410204303320,102010420220000,103002311240000,100202144121213,112001032003010,102010020243104,101022021111221,112102010202000,100230101202040], + 1101000002201100: [100310120141002,103214010102022,100043324210140,102324014112020,102404021403141,100010004313001,100003201021001,103104200210410,100122020011232,100002200410030], + 1114014320002012: [103224310130411,100031411020200,112210400414000,100102101220123,112102400204000,100402210013023,112200302030311,100000001210103,112240024014421,100202141010030], + 1403041021240203: [100011301040031,102101021341002,110002220002220,114404210004101,110011001100133,112121404020102,101000000300323,102322144112403,102024001102302,110031102000134], + 120004302113001: [111304340002030,110102000401214,100100111044040,103140014002031,102024102020000,102224241110003,112003020220120,100043024210301,102014001130100,114022100010000], + 131232004201020: [100020244100302,101201104041401,101402011014002,100002200412020,100102000423142,114410012310230,101423011010400,114000332303001,102141100210112,100022224312021], + 103404234000314: [114420200000104,100043200102020,114142014124243,100000004100411,114022344022303,100422101002110,114124222202102,114000030012110,110004342000332,103102021443001], + 1422101111313020: [111302204133040,110300000011120,100000221020004,101213020304210,111020010022310,114011302300101,102420021400002,103221200100302,100424444303100,102201000201101], + 134202101022000: [101221020011201,102201204040211,114030220011120,110020442001124,110024102010002,100011101011002,100100101220114,111433000002144,100010021211303,100002210000020], + 1114101104001002: [110443010102111,100441224303402,102020101324002,102401030202031,100210031004220,111321012222400,102000104002003,114203204004133,102401004020304,110112214200023], + 1404140430204401: [110443000000102,102430100200123,103300001402013,103040001430220,102020201100002,101032004001004,100000020412412,114042244102400,100142000100232,102301300210214], + 1002200423002401: [100120011004032,101100400333023,104130442103041,100303111202002,101003201030041,112314322001102,110000144202030,110202201303021,103031010100133], + 120002002013020: [103202004001120,1300022002310414], + 130140024030403: [114201010001201,100030024300201,101041404002420,102220310200014,100040300102020,102400110230001,102101011342100,102311210240013,101312211000200,100312131204422], + 1022322202223001: [110022212134022,112014002002044,112000002300002,101030010320010,100421200012012,101441201011100,100032321230000,102320000212000,101100034021010,114001204104041], + 141240040003123: [103020401400041,111001314111000,101031030300001,100100031020131,112111004022140,103110214000303,103000204000002,100403110013000,100030041031020,114001044012120], + 1022342100000122: [110401030003002,102042014000100,112000201123012,101430314040103,103400114000020,100023141220100,101211204013302,112010100204410,100101130400000,112020011110100], + 102231320034000: [110000302030030,110301311303102,100003200120040,110030124410000,110122021200300,101403201012011,100400040013420,101042004003201,102023000211002,110233124211010], + 1013202100100201: [100000041040000,102401141113031,101200140044000,100101234301300,110210400002012,102331104110040,100130414300000,112310002020302,100020410410021,102144002000300], + 1431003004201211: [111220002220100,100000241020022,101133410300302,132200010004401,100030044202001,110114410003233,140200430112430,112144312011433,110000040024442,101410044021332], + 1100001011042400: [110010100442102,114040002330340,102130014134000,100041001020232,110033201204240,100003044241304,102440104022111,110031000024240,100434044100040,122430430314200], + 211011110241000: [104404322124241,114030234020304,102200124012000,114002120023020,114421000001111,121400013334402,114413200000230,100103201040210,144000213202010,112020102300021], + 124002012013441: [111041004113300,102020010203200,100011144312020,103110120210013,100020221040231,1012220402104110,102011204001010,103012004034001,102001410221023,101010111034000], + 101001044024400: [110041030411301,103301210142043,100002024200142,102411000200000,100400014321101,114100122342002,110033041200104,102140101343110,114111104000423,410110432000414], + 1120301330004300: [110132141121031,112101020422004,100021300101110,102030140000022,110201031111320,100000224100002,102024044012212,100000021030412,110403031140001,101012144004034], + 110000222330404: [111410210001002,102104201320013,114220104000102,100011301000021,114310214033042,100100001040210,102014001441210,100013224103322,100000004100140,101031221000201], + 142210002102201: [102011114002011,102031401100332,102144201402040,100014201021012,110000214214420,112010112000311,110030441223002,103010400120230,103002044010020,110100122212220], + 241241223132410: [200224331000220,101231031400202,102022000213102,102001304002000,110231402124034,102000444004121,100400100013010,102311214030014,102200000203210,100401002201241], + 1000044010221033: [110212022124220,100003100410042,102130124000000,102010421413322,110240301111040,102113131343200,111210044101201,111100402200230,101020321002002,111123014100000], + 111010014402113: [103100010212020,102102011401410,101340141003001,101014424010103,102311410222022,111400220030034,102032101130000,102120404000401,114100142310322,112000112001400], + 104020343140401: [103000104004220,101002244004011,101442024042013,111020114400020,101010340331320,103031100142002,100241131003241,110000040420100,100201401010000,111244100002012], + 100134211040222: [100003021033300,100011011020440,102110020202330,100001010014420,101011001103200,114001214100103,101200004040021,114023314013200,102040104000040,114022120040112], + 240320131230401: [102041310200042,101000304014100,110301030010140,104100002101431,110221000111302,114101420030202,114421242204443,110100222001100,110302204433321,101010001002000], + 1020211320230012: [101100011102402,100001114303001,103100214000130,100002020122000,103001031403201,112110032304211,114040410020022,110033020003012,110000400030340,122333020133040], + 110021231112100: [102103222002012,102100244002003,100033010002203,112000101110002,110023000020110,102000200200132,110040240001222,100000404312040,100040004101142,110202112120001], + 1100210221210332: [111120002211010,103122000100403,102023120241131,110014300041302,114241000002004,111232000010230,100424200020200,110321001330010,100000300100000,114220200214400], + 101112220100020: [101300000310011,103122001440001,111024044110202,112402014024010,100103000420004,114232014000440,112420312022001,103141000210223,110003300143000,110001102001200], + 312330042000110: [110122120100022,111100424100021,110111121011004,103001020104102,110200422113400,112000000223310,100002214210110,100011200201230,111001002201034,112024144002202], + 1101014021230330: [102140304001042,100202201002113,112210124040040,110000121310000,100002101120040,100033021031202,112113414024020,111110400011022,103401121200201,100004340000011], + 101044210011300: [110023410122402,111204200002001,103001111221030,111200020004203,104101201240100,100141101040300,102301112004021,110000011012202,100201230412211,101001040302400], + 323043102012212: [102204001121032,100003121032014,114000030020101,100030024102010,100120120112100,112044414003133], + 120230102210002: [100001000410312,100110130411200,114012112330402,114220402322030,100000311043143,100132021014301,100101034031000,110133021140410,112202222021041,110101200002340], + 1000112011142020: [112431212020030,103100314000011,102202000231000,100401002200022,102003301120121,112002044000432,101100204000001,100422224100400,100000421032010,101010011121020], + 241003200000211: [103114001441122,100422004320024,102420031111001,111000302230100,114044144020400,132202000104100,4000113102314022,114334222300122,114140002204140,1400100000042343], + 100112411201011: [100002421031242,101212010301103,104000000010243,110441102112020,100122004323202,103040230104020,100011020140201,111220110000220,110300212000100,101114110330010], + 301333020022004: [102041310200042,110301030010140,104100002101431,110221000111302,114101420030202,101010001002000,110022202130021,111330020002213,114011212320331,100002204310140], + 1001001410014420: [110340200010100,100404304300114,103400021210032,101300000340142,100011314203210,112222424010200,100210001201240,112001102001220,101204404043201,114110210231202], + 112224200123142: [100042304102210,112202000411103,112132434020310,101040100302002,100013030100002,103340114022112,100310034310200,101014014000004,114003022300020,102111210230204], + 1004120311242040: [110340421234021,114122202343044,100140211021431,102110010204021,101001221110000,110402102210002,112230202030200,101434401010412,110012210031100,100131144000002], + 120002030020000: [102001001130100,111204203012002,124020002020003,122222120003214,133332002141010,144000013213001,124010030100142,111032444402403,110103201001321,102311430211100], + 1140044230000342: [110020301220324,100041000010302,102020100243032,100031001020040,100104001041200,102012200202303,101110404021211,103110041442122,114210400000112,114042014102321], + 102400320000212: [100120221021011,111242212222022,102022411100012,103220200100320,101030004004303,114000020034200,114010214032000,100010001040020,102014014004002,100004120012002], + 100110120010004: [101012000300043,110422011240010,100010004101244,100432211002022,110100012142010,102011114001033,110030042003121,102120001340020,111023020021014,101010001002102], + 112301043220100: [102231102020200,102120201140110,100331200141014,100200011002042,110224102230230,100120411200320,112401344040043], + 1100120124003122: [114201010001201,100030024300201,101041404002420,102220310200014,103231224012042,100040300102020,102400110230001,102101011342100,110012404201130,100021100412012], + 210414002110123: [114010200011100,100102110412002,100000204214001,101142014202110,102310110213220,100012001042030,102000404000400,100013040404011,102004004004200,101002134011001], + 341002431430012: [100020300200110,100042000200211,101004140304211,100021024100301,1101210010010223,100000241033100,101000124221041,100000134100120,101012010303400,1300102043130042], + 212410220140021: [111410202221302,110002302101012,100111401011110,100114110411042,100223010432101,100002004340344,110100400031432,101041300300004,110204201213200,102141311343023], + 104332030030410: [112010420232040,100032114202001,100220410101001,101023024210000,102140322001242,110000442001100,110201401201230,100100311044101,112013124020300,110000020440133], + 1020042100021110: [114020000030002,100201211003004,102014002000401,103103241421322,114121012340044,102000400240203,102104304023201,103310300140324,100002224244002,114310200002400], + 1400110440303012: [101101040010000,110021040023140,102004001131000,114002320024211,103031301240234,102121100212102,100114100000104,101300004220200,110020402120123,114320114030010], + 120443021001140: [100024000110221,100110020031042,101301014221122,110422102110221,114220040000201,102102204022310,114130014001202,110010220103020,111004100022110,103030040121410], + 241141200002401: [102001404012100,1010400230221020,102302200210010,102340120222440,111041202200140,111300400002313,111101040014040,100023014313010,114021040010311,114140004123122], + 1023001200413320: [110012220442042,100001114303001,100034204311021,101121024024120,110023100420044,103332211400441,103011131430040,110320204424100,114200112330011,112202114010130], + 1013000031040302: [102101204000030,100011140101103,101400304020120,101003001021020,101420220300100,101001004002021,101012124213020,101004121020134,104102220014110,100040004100310], + 123010001202014: [104100012102004,110021232000021,100401241014100,110301322104142,100001140000010,102003000212200,102420020204200,102000200222121,110033002000020,110343014421300], + 1010001221112030: [110430430003002,104412212102010,114102024123030,110300011333202,110132020031210,101021404000220,100020200102220,110414012023214,100400100010101,114121200222010], + 100002323233111: [101230002122040,111124004101012,101210241204043,104102040011120,114103220220104,102120004001310,102430121110340,102020121102120,112141104020201,101200111020111], + 1400100300120011: [102322020212020,114413232320000,100100001040134,114441124140100,114000002330112,100020001030232,114422234140240,102341041104000,102000100221110,102341004020202], + 130110334030001: [100440444301004,103304014020032,101221121020230,100232121210011,100004110000301,101310004223223,114113004120221,111210402244301,112022200234200,102100011341140], + 1110010211201000: [112302112020021,112010032340022,114120304000212,100141410402200,114111202313213,101042041021001,100010031232443,101211414040000,100242024100000,100114020414244], + 120241012104130: [100013304331301,112000022302210,114300014030130,112021204000310,114021140030012,110014240130030,110221412114120,100131241204104,110111242012201,112021224020432], + 1032230001212043: [102401121113302,111201210000103,100101101010100,102321044112101,101203011023020,100021231020200,114201112322020,100042020102003,110324010400214,100141011023021], + 100022113200002: [100101130423301,114000100020002,100040321020030,100400000010033,100400000013010,101322020313110,112020002002301,103224101400400,114020000010111,101000111001423], + 120300104003221: [101400100302311,102141000230040,110030024202101,110100224200101,114000102300220,111011022203010,100001000100020,100132444234001,110103401303010,102042304000001], + 1000010234100001: [102001231413224,103003024011120,102030024010020,111320000001004,101004204211203,110304000402222,110201002040204,110001141011223,110010402102122,101211220310040], + 1030004024000002: [111020030040120,103030404010000,110021002130201,111302202204022,100120231204012,112003402002003,101023114001014,102012044013241,100002100122314,110012010122100], + 1002211401030024: [1010400230221020,103034010121101,102302144110440,111300400002313,111101040014040,114021040010311,114140004123122,102143202000400,100002301021040,111020002202333], + 120000210223020: [110020010134221,100004020411020,100300321000010,100000421021322,112331012023100,100021010100320,101001030303000,110031210000110,100431024301030,101222321204303], + 102004122023040: [103000004002012,100002011042020,100301421002002,100202140000111,103022021431010,103200020111014,100240101000030,101003104212220,102120231343021,102302211002004], + 101403010243020: [101021134011012,104120130021200,112421004012141,102011104010201,111100220022101,100021104201130,110030410040101,101300401002320,101110434020010,114330002300133], + 100004132023101: [101321001000010,101010424210144,100130014300042,114034400040402,100010100102032,112023031130013,112010344023013,114002002300222,102104000210330,101401300301000], + 210042234020000: [101142124022010,111200012220040,114130120222102,100402120031033,110244004430214,112022012301001,102101104000121,1000000230020301,100102411011142,112403004010231], + 102021030310000: [111000022202402,110014032101430,104421312102244,114131014101010,102002301442023,102240214041033,114200322333401,103010021422042,101110000010122,100000001022401], + 301042000003204: [101042104010000,114000122301411,102111002001230,111102010020434,110410000002004,111424002101030,100414231011020,114243204113000,103130004003141,102323210243022], + 200102324420420: [101230002122040,101210241204043,104102040011120,111311120014011,100123011004113,100420001002101,102430121110340,102020121102120,112141104020201,102000024000002], + 102012303100111: [102102341400400,100013114210003,103004210100021,110401400000302,101041424000304,110140000001113,110021232002011,114121044001401,110410310002012,102204120201122], + 211201032040002: [110200140401144,100430200431021,114310100000110,112002020214003,114400022311400,110010220410220,114040010022000,101133104002112,110400320001110,112140044022100], + 110012114000204: [104103101240204,100020341001100,110020110400102,110012112103040,100104204100000,114222204112403,102040011412033,102201230202444,100411134304010,103222001422300], + 130411200214012: [101214440300301,111102214104403,100132004231230,102301024113440,100000030000001,101104120334002,114123234100223,100222024100230,110302302001423,112000042000001], + 103423111232000: [101444024041143,103020001400040,101023020301100,110200332041001,114004020010203,102014001441210,100203030110000,101004200341000,103033034022011,114022304100241], + 110410111032004: [110332424431130,110011414201101,114400104140001,111120442100320,114312112320302,110000121033240,110122114404243,103100024003112,111010242140140,101112121144002], + 1411102124400020: [100222000004100,110002001222210,103122204002112,102120000202211,102112004101201,101103320301203,102011001102101,100402020013010,110003004212001,110310430012302], + 300140010023311: [114122104140200,130031110003001,400124411000212,101204031214100,100002010410120,142201000002020,102242201301140,1321022130413330,1023031101004142,420023000041240], + 1102110212114002: [101204334232020,114014224011404,110012302001040,112012002303014,100210421004302,112040201114201,102003101130231,102240200214023,100101200410420,102101024002102], + 1430022100220030: [102041100200402,112100404000230,110400112021140,110112121002403,110122221240302,102241230200120,110201111200204,110400104222012,100000001034120,110000002131031], + 101022400320104: [110214024430312,100011014100041,100212341003212,112013212032000,112010220224003,100200001001300,100012104313201,110212310000041,100040424310110,111301332200104], + 1000003131413201: [101410211021400,100004214100234,103000011400001,110402410002000,102001011442200,100324200110130,100342120144000,102020001440011,100100031003220,100202114303000], + 1010230110102001: [102010010222302,100400120020132,100121311023012,110020222000021,110003002121021,101003000321304,110030130030200,101101111042020,110010300431001,100021030111242], + 1113140101032000: [102023211411003,102340200224222,103212000212121,100100011010220,100124011040300,114114414122002,114320110001030,103211014000111,112120340203021,101243010302200], + 1020312402402124: [110020301220324,100222004320102,100041000010302,102020100243032,100031001020040,101110404021211,114042014102321,102112222001200,100021104100310,100104024300120], + 1000204023341114: [103242420100012,103130311444100,101040004010012,111343012200000,102201430201310,102340040222321,110413402111101,100004101020200,102422000200303,101222220302400], + 103430013010243: [114130012310000,102112432004423,102402124022000,100243120430140,112214431102032,102032204000102,110120032013303,102101230310000,101001030310014,103004041410020], + 140001301003021: [110023401320200,102301224110000,110000312001020,110214110004122,102133211401043,102010214000003,114032204104044,103002010100104,100220310430010,102410110232000], + 1040404030124340: [100104100022200,101120201100110,100102321001302,132100001222020,110244014240010,100142401012040,101320420300210,102100234022140,102200011100023,103021044011200], + 1020232111010140: [100423004302232,110030220000310,100110034332223,101223100300200,102001034002201,101104401020410,102032031440302,100113004304010,101310311000124,111303214132004], + 1211200234102112: [110021000410432,100042304102210,103202000110102,100013030100002,102020440220202,101010010320112,100042000000000,112000021122010,100021111043012,110124041140000], + 210430101201321: [100400000020210,100032000002120,114011300040140,102313234112000,100424011014010,111101100020030,101010224210000,103003210141014,110240032042222,110200022124020], + 1042032203340200: [103000011402201,110301232000100,110021141213001,100000244300040,102332001001302,110110234204100,102001021132022,114004310024404,110210134244100,102102032001300], + 1121203101224200: [101101401204230,100300304101202,111220014133001,110301010010124,101311324220211,103200041202101,110213002020030,103132300122020,100103020010000,102220120230010], + 1000214120001004: [103000004002012,100002011042020,100301421002002,100202140000111,103200020111014,100240101000030,101003104212220,102302211002004,114030310012122,100043021042120], + 1102301203103310: [100032041021210,110004301222000,102040011121100,114310000001232,111322234130000,110104002010100,100030024303023,114142044120310,103100104000121,110024140142000], + 1122110014210024: [102300100242401,102010004001300,111223042243230,101221121020302,100100221040404,110000124410003,112122034041020,100000030022004,101032341110042,110110121300321], + 111312400002223: [100231024320200,101001221022240,112014020232401,110201200000412,112224040202200,100020120112303,102403004020021,100041404202111,140322200322441,103243214023020], + 1004100022122420: [114404010003320,112000002000420,100013200412401,114030412303102,102200320200003,100430000030122,114300104032040,100100101040120,100014011034001,110143001120200], + 140001310300200: [112004202302034,103300004021200,102122214131011,102100104000040,100023031000024,112120224040040,100020004101012,102402000201011,102311011000200,114200024110134], + 1110200212002001: [102100441341013,111130224102101,114201000004122,102201024041200,101223301020130,103312401404300,102322020212020,114403304140021,100031131042030,101010134000004], + 111102100202021: [114002114012041,102012111102321,100111214302000,100104104302020,102212010200043,102000000221201,114121024120120,112101230204411,101202134232021,100012334310110], + 304024020001100: [102100321320100,102102011414242,100041004100221,100000000412112,110000010033022,102330040242220,102310400240000,101201340300430,111320312222220,102210000201040], + 114224120220113: [102000004002101,100422314300200,101403014020203,100123011004113,100420001002101,100042030120422,101134224001001,110020001224021,102321234111310,101004010323441], + 1101020301403100: [103100314001030,114101004121020,100040301042132,114010040023411,102001010222103,101021104212100,102102241341004,100000101030412,103031000121000,102020300220201], + 123212203101140: [104111102100000,101021004000000,110000102100212,110130042014110,114423100002212,100011401040040,111121012212042,100001020002400,110012102130100,111000230041031], + 1004020020011032: [102030004002200,100040014210402,110014012001011,102202014030042,100100410401030,102000040222041,100400430022423,100201314104221,112323230202030,102303044033020], + 121300041012021: [100010441032031,101231211020143,100022021024200,100024100201424,101012011001200,100003014211000,102012214003000,102142020212310,100102204301113,114100220004120], + 111221000012204: [101421000300000,100231100410023,102020424011001,110210000123320,112130140200243,101043130321113,101120100020310,100400420013021,101212040300120,101000121141320], + 210143112113133: [110111400400013,102101300210200,100041044100100,102041014011220,102301104110010,102320001000040,112300031103011,100100140024100,101420321010000,104100042101240], + 1002014022024202: [111203024131300], + 130000124021121: [111124004101012,104102040011120,114103220220104,102120004001310,102430121110340,101021204000200,102020121102120,112141104020201,101200111020111,110001200422320], + 1033242102113400: [100002031120341,113020001020004,100003044210040,103243401401133,110012212132410,101210014200430,110014011320012,110400022122040,101111010020120,100223400002001], + 114102140114442: [110000202003120,100130220400000,102120010200131,102312300220000,112221024002232,101142014202110,102310110213220,110020120041030,100013040404011,101020111140040], + 134200101023110: [114020000030002,100201211003004,102014002000401,103103241421322,102221414000020,114121012340044,102000400240203,102104304023201,103310300140324,100002224244002], + 142342323300004: [100003011041040,103200141404212,114014010043112,114001112300222,100203141001002,111000312112404,101002301030040,102033001133411,114122440000024,103000020103121], + 1110044101010300: [114010312242141,102401221402002,102102011342302,114000402330220,100000044203240,114304104031224,114223100000020,103143000120100,114100212201200,103001010120120], + 324040400134020: [112024442000120,100024010200212,110200002122130,112002022302433,100010021042030], + 212100120211310: [101204444040122,102114240204013,100011301043341,103001000120011,103121020222040,101102010301021,112223222033013,101002024003002,102011010232300,100002200202041], + 103100100242202: [102343230224321,102112231020231,100022004300020,102320000240102,100042144200000,102030304001101,100020420121003,103020004011414,100001104301200,1001300002020110], + 1030103000200410: [112001002002140,200003230020033,114101104124300,110040000440000,101140114004004,100402320010000,111104300010000,101040030302203,110131421320200,101201001012001], + 1012100000112241: [100444212001030,132110011201141,134230121002024,100402310022042,200101033142340,100310001000200,103012001410200,100233001001411,103211024020021], + 1211312202020100: [110000012103121,110212201200033,114010234012413,103114001404102,100400310020430,100011040023100,110001012001403,110120134222021,102214214042032,100021234211320], + 1000001411012400: [103304001401001,101210104011110,113422210102022,114002014102000,110201021102400,100123110402022,100030300121000,101200001022000,110021102002003,111124004102400], + 1401101140012203: [103201200111010,110430011311010,114102344121242,110012231322200,101022000320120,114003300023020,110003310021031,132202044122440,103224324020100,102102001000010], + 100341020001013: [114400034122341,100001101023021,103020001400040,114002004033124,103030324000302,102101104000212,111120010020104,102002304010024,114022304100241,101000011111400], + 1141201331100340: [102021400220100,102301040242220,110101312120110,101020041110102,102110031342220,101401414024002,113001042202101,112002002021204,102140111141440,101222131010322], + 104310101024114: [101211002120221,114421404120314,100200120430120,111110232213021,114202244003043,111002042204201,102100144021210,114443002314112,102000121101120,112002200244001], + 1000121214201210: [102340200224222,103212000212121,112002010220004,103211014000111,102000034013222,102030021100041,103210214042004,102311020240120,102110110210032,102202001113034], + 100432030420010: [100114041040204,110100114220010,111220110002020,111040004110102,101022200320001,100040010400120,100030140002221,110404111001032,114140102320411,103022031411010], + 241301122240320: [104110021244203,102224101113104,102103022002001,100312331004000,100142431013000,101000031001011,101010130321200,114004322330012,114202144102100,102102401412242], + 1001220102031103: [114100012313002,102001011442200,101004202403121,100304320140012,100200034020100,101200100301000,110100000100000,114404240034104,100020001041202,110104000034043], + 221110001000021: [111123010022304,112003001133011,110213002132000,103010000110210,114003014100103,111010132204402,112102204024002,100100424030003,101000131030120,100031000004222], + 221014011010424: [101012000320221,112012002303014,102101204002343,100004340004131,102010031100000,100200411000410,111021220021002,100131201202420,100220111000200,102221014033000], + 1023113120020310: [100402210013013,112032040234431,110010232004000,101020004000000,101004310324302,101010030302022,100120040400011,100214044220201,110410002020200,114321224032200], + 110020000330402: [112233000410001,100021214200024,110102044223300,100230211001001,110402042222042,101001411000403,114014000010301,110102100000223,112121212311000,103004011410021], + 1002412241210120: [110400112011100,100321004011041,110002342100014,110241024242442,110021312002040,111101042244210,110441010002400,112220001100200,114203104001000,114302200014241], + 1010200202130120: [114004104100000,110402100100230,112303010200000,110001120042000,100200201002303,102000024012202,114200204000020,103111000211000,100003104300143,103024141414040], + 1034102201042200: [110211010014110,110140402004020,110012102100200,103000104010221,101012104010033,103024014040010,112201421101233,110032114200240,111300432201011,101000201032022], + 301412132130021: [110202004211120,110223224433004,110341010044330,102031144010424,100302420120212,111212114131222,102140001441301,102223400201104,102342120222031,102221010201113], + 1010003001121012: [110041030411301,110001041213031,103301210142043,100002024200142,102411000200000,100400014321101,114100122342002,110033041200104,102000221442214,102402104022000], + 132234204303001: [110400022010030,102130411411444,103103204000110,110202204213200,100441301014410,114142102344221,102404004001203,114001024010010,111212204420203,114230020000033], + 1102000022023100: [110002212130403,101042411000122,112041402312040,103023021244000,100224210432130,101002024012004,100120204234213,112030022300112,102010204002000,102102004031113], + 1030010401020022: [102224024011142,100101401040102,102322001000010,112240330200110,100114010023242,102014001100101,102100401400123,114010120044013,100032204102203,220310441312320], + 1040221243020001: [111202114103220,103000121421121,114404302200120,110140011300020,303320304020413,111020012233400,1000313001212002,110013024421020,110001002010000,101043021021030], + 242040330022142: [100003021033300,102110020202330,100001010014420,102101220214011,114001214100103,101200004040021,114023314013200,102040104000040,114022120040112,102311110240101], + 1002041020223101: [114201010001201,100030024300201,101041404002420,102220310200014,103231224012042,100040300102020,102400110230001,102101011342100,110012404201130,102311210240013], + 1042211233322113: [103130311444100,111343012200000,102340040222321,110413402111101,100004101020200,102422000200303,101222220302400,100044201210002,100000234101201,102402040200201], + 1422302220034312: [112000302030120], + 1100012213200103: [112014002002044,100421200012012,101441201011100,100032321230000,102320000212000,110122240004011,114001204104041,101240020300231,111240120002010,111102212220414], + 312122430021021: [111102010012102,111300030012334,110012000141104,140300020110000,100003301030120,103044004034040,102200301100040,102412140201410,102024110224001,100341231000131], + 100100001423312: [112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422,101002024000400,102202031002304], + 240122101002004: [100232121210011,112022200234200,110043132100300,102220120203200,100002004201122,110132031134031,1220302241034202,100240200430040,114110342312140,1202111000310100], + 100300221400004: [110001230044420,102100111413102,102201110210331,100012010200202,114330000002220,102000401130003,102000211410100,114004312330002,100110110020203,102110214004404], + 1044101301024431: [102010104000124,102424000230222,102102100210000,100002420121000,102001301320420,110202012033100,112000001132100,102213214030121,100004401020202,102002001442400], + 130101000320304: [100212424322433,111142000011122,103020201401020,102000401132401,114022020042232,100200410434002,110002022130324,100221124121143,100414300433033,102040001032100], + 100024402024202: [110000212000300,100000010202003,102400001110102,120413040002400,101221001202021,112020102001020,110000401310201,110001004413010,102001030240003,100040331020102], + 1400001000201000: [100003224334120,100404224300012,110204130004030,110003200132101,110202120003032,100322004314021,102022010220223,100404000020012,102343301100440,110110440020002], + 1001300331002023: [102010040210212,140230300211231,100030010000110], + 1000400210410031: [101400001011042,100002011020211,100100110010010,111110002213142,100002131030310,111102214100400,103220201402330,114020010040100,102100002004041,102321000221140], + 113333000102303: [114402404141241,100200400430003,110212022133311,101041210311410,110022004211030,101210021021243,100140024230240,112230240412241,110000204203220,102214000210013], + 112002142001021: [100000020004101,110011232100412,100220040142222,110232002101410,110020120040121,110200021210212,110131021240303,103100101442233,100000031220100,111010000021300], + 1001040042401010: [112401024044240,114203400000000,114014124030001,110021401213103,112102004020111,114000010042420,114102010210000,100400332201021,100042021022002,100100004300002], + 1004220004021402: [100043104240004,110002034200042,100001240100033,114100304002030,102100001340122,111000200040314,101014001001410,112030010234104,103414101212410,100123021223100], + 123112032002242: [114002200000421,110240301111040,101020321002002,114030004104220,114200000003241,100104004301000,102301041000014,112142011101404,100210004221341,102230410202021], + 1020100200221242: [101133001104410,102113110210240,100341130142101,102100300210100,1100000411441420,102440100200000,1002203010011112,402001100011120,100020321030202,402202000003002], + 1004021010330222: [104103201240410,100300204010001,100011320043322,102204100232030,110110012110224,100200011220231,101004410311320,100200310110000,102002122014040,103112010212244], + 1420112222101032: [103240411403020,101020030332430,101022004214304,100020101031131,101010000323030,101001414212120,103310220113140,114200202330330,103101101440200,102114104001041], + 131320310024001: [114033300040100,100000000412112,102330040242220,102310400240000,111320312222220,101241100301411,102002140220202,103000101414111,100001000012021,102304001004200], + 1114011144102002: [101020204002030,103100030100010,101400004022100,114031212300211,102013110201200,114023010024000,102042321440100,114000204101231,102300121004222,100000400412200], + 1023002000202412: [112000112000031,100142104100403,114202204113222,101244001000204,100340000140032,112024000213011,103013024002104,111000004400110], + 1121130004304101: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 1011224200200000: [102101004000411,101200210300413,103210021401223,100323140143012,100004411033203,100002211032042,103202211423100,110241042102233,114101000003304,100100314102200], + 1023004101000202: [114222004004201,110400323041022,1134000004202341,101140334001111,1012321211130014,103224040221400], + 100300203122004: [111220204101421,110042120021013,112200420200200,101001010300011,114012020044224,102122401340101,110021020001220,112001024000200,110112030401012,112020012002031], + 112014030121410: [100120011004032,101100400333023,100303111202002,101003201030041,112314322001102,100421320432102,110202201303021,103031010100133], + 110112010031201: [114112432204002,110412001240302,102044001440122,102400304042142,100110004103103,103230304022210,101004204000013,102023120204401,111120032214004,100012204310100], + 134040004240130: [110001022000001,110002012000400,100021004310222,110020422131120,100001000100000,110202222043022,110313312021120,100220214333200,110330234422000,110243000001123], + 1042024202201024: [100240000032004,102000000210211,111010204401023,101200010300001,102211300204221,100301004321221,101220200040320,110440100030213,114402412200144,100031200001240], + 1034212044240011: [112102202040000,114100002204212,102003000212104,102030204000041,102110021341014,114320100002004,100210120430200,110203221112042,102110001401222,111201300013403], + 124300300221202: [110224044242243,111124010022000,110413402111101,114313302330131,114223040021400,114220334110000,114420004143002,114310000212010,102141322000030,120310230422021], + 1034202041042044: [102020314012030,102322020212020,102020224000000,101242101020042,100031131042030,102421010200213,114021040001000,114110000002010,102301141002223,114000002330112], + 122001021422131: [103204214040130,100142010410011,102041410242244,102323201000412,102212434110001,112102314020000,114010002304030,101300040310000,100012124101001,102110021023034], + 1414000200320300: [100310014310311,100400000031312,100400010013000,114110024003013,114142102344042,114114040001042,100000030003111,103002004001434,114200000001000,114031122210003], + 1000302102201001: [101122104200222,102130104030203,110220032110210,100040114102013,101000004000014,101100024022142,110140004200421,100010204313001,100000000004000,110024022200410], + 1202334024124233: [100121230031032,112000431120410,100122200012014,103042024040104,102304104110001,100104211044110,114241222321321,114021002302020,102313204114304,100013200100011], + 1101014103403301: [114300022300010,102011424013030,100420014301302,102201102000000,103012220110230,100120421004010,102012021101230,112220430200204,103121404002104,100040424301120], + 1000030402214111: [111022412140224,100212034221414,100121301023030,100020224310403,100020424102200,101121401110420,100200001211010,100221044022102,102414000204201,100102004220432], + 102202141021001: [103120400210000,110234012243001,110000214202000,114223212320410,101004020312432,100302114311412,112214114012021,102220311111011,101200204234130,102410004040302], + 302000112020002: [110240301111040,114200000003241,103103404004112,100110120023012,101042044010040,112021014022022,112002322032030,101040401030013,111300002204430,102202144022220], + 1010310001322100: [110200000113011,102101001340020,110002202130110,102032114021101,102110210230401,101040040322202,101422244020101,102142120224022,102104100233030,101210010304011], + 1421020201234204: [103111010102100,110230024213001,100403312201120,102220030200111,100411221010100,100421001011020,101022401000022,100000414100213,102300011003010,110000321010110], + 1012212002012302: [114003212210013,110302012103114,103023101400002,110010120440200,100002100100320,110100034200300,100401201010220,103200024021204,102100204000234,102043221012112], + 102142440100142: [102232120200100,112000142000331,112100302012200,100022341030311,102010100223003,102101001341304,111004314403022,100402100022022,100040210100004,112042002002400], + 143113013210042: [102430401401200,101401000302120,100000020413120,114430014144403,101343421000022,114021424032110,100023024342204,112020002300103,102012021102214,110102200030440], + 1001020304000241: [100021400101221,102241341113010,102300020241001,114100124100413,101001114012114,101141400302200,100002044101122,103342424024214,100100021040420,112002242001002], + 103410100000040: [110424002020032,112002021120230,100032344310121,100302230142111,110010110002202,101412010300340,100102244234110,102020341130000,110102020012000,110102220020204], + 130210004211201: [114020202300000,102020010221120,100104211041401,100010400101020,101220021023030,102001001100042,102000020221210,100020131031104,102121040220201,114014102300002], + 1423300020022040: [110020231214220,100002000000200,101040200321020,114224000000010,112413012012020,102010104011031,112004142303000,102044421103004,100004100020020,112212000202012], + 102010110320040: [101232314010241,100301300121100,110042400130000,103020124010320,100021300101201,110230022122031,104101201240100,110000011012202,112102112301130,101244324043222], + 1041013411400020: [110230030014304,101421211012113,102000121122221,101222200301320,110002012103110,114112244000201,110020210040142,101000034004034,100204141000201,100121004300112], + 203000421043300: [100030001020201,100242141004122,101302401003202,100004004102002,100011114300334,112020201120340,102303004110022,100110201042101,110134201140010,100000001020344], + 1022220114241420: [110120200032000,114132242201400,100033000122213,102140011140002,110110402012311,100041200201020,101422000302424,102204024011121,101101430332010,101012100320111], + 1013201020121320: [101230111024130,1112100200412130,1320100232411004,1000104021012332,1020024112001010,1000343442023043,120100010104132,111401004420001,423203002400042,100141040401001], + 1101000211211030: [112112014020002,100004414100021,102113101342120,100004340100020,100002141021000,100013001030230,102212204012004,100042001024000,103101004000424,100100421020012], + 110104042210201: [100031034311401,100023210021210,102100104000203,102031011441221,110200101200402,102021201410011,114103020221100,103211014030010,100034124101023,102400004021004], + 1001310440104414: [101001044211204,102100010233022,102120400212001,114313022302101,103001324000110,100002014200021,102300401001010,103212320212011,114000030014400,111120034400000], + 1400112300142210: [103030411422014,103043334040203,110422201312402,102120131401230,110200302024000,110210020104031,113130020101411,102041210224224,112200030203124,102004020224404], + 110120400100030: [114011322300320,102042321133010,114011142210000,102200411122001,100200011200124,100201301002301,103233224022102,101200004042014,112120100220010], + 1102000001241003: [100003031030034,101001044211204,100031034311401,100023210021210,102100104000203,100000140100020,100002014200021,103211014030010,111010024402022,110000030411013], + 1122204010000404: [101200400041032,101041310301004,102232110201100,103001224014142,110000000143124,114431224113420,114033012202420,111211002241330,102012000213011,112040004000012], + 100100004302220: [102210224012020,114313302321311,102212300202110,102210304013310,112101020200032,112002002030004,111103214104101,101220000302410,100004210412101,100024414212001], + 1102230110140202: [111201312241430,101011114210004,100000040410034,100010030122310,100003314100400,114002410041201,114200044004232,111212412220144,100002111231143,100102104102133], + 131132004102000: [111130112100210,102202200240222,110131044200121,100100004102234,110223332120231,100001024301322,114013044102010,114220114140122,110200210110130,100011201220003], + 1032110022310110: [110002004410202,102103114000024,101101410010023,112041002002124,140343100002103,400200234320200,101041200320322,110200320000000,100001424102041,100100021040230], + 1101133022102010: [1010400230221020,103034010121101,102302200210010,114140004123122,102143202000400,100002301021040,101321311004010,102411201112404,102110241342210,114122302311011], + 233002011044010: [100012230204000,101101200311102,112401402023020,103142104001331,100200204123011,102012024040044,103031120143010,110020211221100,100000010004223,100101130101111], + 1400004134041232: [102304130242220,110234010110023,114020400022001,100020034302021,103001001424322,102002221100222,100124030401241,102101044001201,114123100221401,101411301011220], + 120213400311020: [110020000440124,100122211044424,111120442100320,114312112320302,100020230104020,100212324104022,100230000410021,112102020234420,110120241324003,103100024003112], + 1044340110002001: [110120101220000,101040014002010,112001001133213,103112400210001,102000144014000,124204212002003,102400041402003,102311101002242,102110210210004,100000100412410], + 1100324202220103: [110120102041110,114002242304240,102100111341030,110213131203122,112114004043430,100002334340000,110010432000001,102111044004101,100121101023404,103310324030320], + 1041100120012210: [102121221343020,101010101022202,112104424022201,100013211002142,1302314034023041,1300034431310021,1001010233020100,102210104000000,112012200120020,111023100040110], + 1130320044004240: [114002014104121,100011200400003,100110110031302,101000000323002,100022114104012,102022000222343,103204140100110,100102401041104,101210010302032,100200004031013], + 100122000400104: [102202000201220,102203011120021,100401140034220,102103122004211,103022230124332,101242004043300,102102131340404,101010334004200,103003040102120,102420041111041], + 1031303034032022: [110310422121022,103000004012011,112121310200022,111020104110040,111001304121002,101034404001420,104032001243110,101022024000120,103410110130122,111010312141210], + 330004004001000: [100121230031032,112000431120410,100122200012014,102120400212001,103042024040104,102304104110001,100104211044110,114241222321321,114021002302020,102313204114304], + 122113420031031: [103120224003023,100020410124020,103123241213321,110131142010001,102100204000022,114142312342002,110000104203121,100312200422101,101200001020200,100031001031042], + 102401100002212: [102041020220100,102023031321010,102220020201230,114041124101040,114004202300322,101401424024210,114003104100012,114010214013020,100112404231200,102303021004001], + 1103003300403121: [124010311303140,111001202231001,202220202402001,110101201010021,101200134041120,110214302104400,111024304401122], + 130210321031400: [110402001342101], + 120311101100000: [100010101043200,100231024320200,101001221022240,112014020232401,110201222120421,101000011020103,114121202312210,110201200000412,112224040202200,100020120112303], + 1034020324300201: [102104004021010,112033000244420,104132001240113,111221000010010,114302044003120,100001104310020,102000100240000,100202234032222,101024034001210,114400220000013], + 1140123020100130: [103100304000100,110100012141120,101034204000304,100140040401300,100221020410000,110101211201003,102021421442001,102220044000002,111002100002201,110301002000101], + 1021102003320000: [110202032123210,111122004100020,110412244220110,102411314024401,114001002300430,110101230100001,104102130014402,110314042102142,110411130100013,110000022003412], + 1103414201201101: [103020031403100,114000044020204,103202430100244,102302331003300,102320000221020,110142020400012,103131420221204,102120141343312,100400201010114,101420111104213], + 101223144024303: [101100004002101,102121130221024,100031404344111,102034001100100,101400004040120,103030034003020,101144010014213,114022234031002,110034201323201,101204020300122], + 1210223202123040: [102130411411444,103103204000110,110000400030340,100441301014410,114142102344221,102404004001203,114001024010010,101322100311212,100041110411010,114200100000143], + 1024012000130001: [100022211042104,100100204230423,100423202201102,103131000120022,110004021102300,100130001021040,103000034040110,103100214000400,114200122301402,114221310212004], + 120442410320200: [114034220041220,102100422004010,100024004210111,102002100222202,103200234030122,101001100320224,114021004100002,102200001122202,102140020210040,102100320220140], + 1124041200314222: [100020114300013,102210010211020,103244411403100,112022104004013,100221001000220,102203114032020,110340004423020,112032302300201,100213204101112,100023020020241], + 1121402000014003: [101023211102101,102022001101234,114220102332012,102000304001202,101233100300011,100001314100400,112101201102130,101004040320002,101000201144300,102322144032100], + 1231114011014204: [100222000144103,101240000310400,114022002211402,110211000004002,114101402200030,100000034200300,114200022322000,103133001441320,110320400111012,112212111100021], + 1042110233401322: [102424204043100,112022334022101,100300211000020,101410401010030,103240001403000,102202204040220,102103100310300,112002014000112,114020200031000,101010231002004], + 100432020002400: [110430430003002,110013112004021,111012104400010,100432200033101,100100004100200,101021404000220,103120140210020,102143211343014,100112000410320,114420230000240], + 121300223333102: [100003101003001,100012400101400,114301120000030,112004000214201,102221002020200,114104004120020,100020224101141,103100201420104,102300104020420,102001101132230], + 1011111020142310: [103003400122221,110040431301211], + 1120103330040201: [100022100100000,110100000010002,112020204004003,100122120411101,100200000011304,101411440301101,100122404230023,101001034001034,102204111110031,110240100000322], + 130243024001004: [102100010233022,102120400212001,114313022302101,114021002302020,102313204114304,112100102300200,103001324000110,111201424100200,100002014200021,103212320212011], + 1001000224021010: [110002022002032,110000242002021,102023301101100,110042130002002,110211114244021,101010000324423,100402022201021,101004201142324,110402332010103,111111110022110], + 1100104101042241: [103300344012201,100011200201400,100201104224131,100002100204114,102203001300000,102101004001020], + 100043300024121: [102020314012030,102020224000000,100212024121000,102304110220101,102301141002223,112014010202200,100000000410010,102001024012440,103201000102140,114220100000331], + 120000000002403: [102100321320100,102102011414242,100041004100221,100000000412112,110000010033022,102330040242220,102310400240000,101201340300430,111320312222220,102210000201040], + 1001002200013042: [102042031102112,102102031403230,100041140201301,103021004022022,112122334022424,100102101041221,103011100120201,102002030240400,102300004110122,114000202300004], + 1440402030031002: [110024021040134,110301001232000,110000310134014,114000012334010,102001201443121,100200024301301,100202421000201,102400204022024,102002101410204,102111002004022], + 140040200312101: [110203022120020,104121030021030,110004320001413,114303000000120,100402200020301,102132204003422,100200144304301,100203321001203,110000210041101,100010304102110], + 221001304220012: [114103004142211,102021122110400,101212120302000,100000401002221,122300200130321,130312421011034,130221000032423,141221430000144,140140230202204,102000134002210], + 1004101230202300: [110410041242140,102433100201040,110000000040042,101213110301210,102204414041020,100102024232212,114002102301122,110200002121202,114020112202104,114102122200241], + 122102201010000: [101132101110121,103223201411202,112001001132010,110221412114120,100041411223021,102010004010033,100220111003420,110100400123120,111102300012024,100002301020132], + 1001303202443012: [101410021100102,100110004101000,100040020201004,110402402020010,112421302011301,102000034000000,112400200201000,112100020204342,101212310301011,110402030400142], + 222001221001300: [114034220041220,102100422004010,100024004210111,102002100222202,103343010113030,103200234030122,101001100320224,102200001122202,102140020210040,102100320220140], + 114044040101102: [110000000003200,111202004100121,101041204222101,100024024211001,114031000012100,102110001342114,110200000004322,114342044032200,111110020000001,111203012221030], + 1001001144003003: [111020030040120,110002000134011,101122040304410,103344200113430,114101104102004,100302121000100,111302202204022,112003402002003,102000104003032,111011402203004], + 113002002002324: [100130041013100,103120111442002,110022002100101,110433424221403,101310010340104,103001001220244,114124404003211,110014440412204,101410004022002,102243102002020], + 1102000002011131: [102133011413110,114022424102243,103111420110210,102022400203211,102131201401041,101230020303000,101214240300041,114203000002040,101410104044024,102102230210023], + 130030000124041: [103000004002012,102110030200120,100301421002002,100202140000111,114001032300011,100240101000030,101003104212220,102302211002004,114030310012122,100043021042120], + 111004444200020: [100101011010340,111111000014001,100021320123031,100020001011422,100014041042003,101023321000020,114033400011210,102010221132220,103100204000400,114020000022214], + 102100221104023: [100040201012040,114100222310230,114131002342130,110002022003101,110224130002014,100403122201202,102303304020122,100310210142030,114132012200110,103011011410312], + 101400320200002: [110042220002210,110410200100200,102113340210000,110011401011100,102221200204022,103021030102410,110430314220010,100004014300341,114100212211004,112001402002232], + 321200424241222: [101300124221002,103311100112220,102112002004120,114400004141104,102142234000020,114402044140023,100314420140013,101401204040200,102132004004123,100040021031201], + 210200123011100: [100312331004000,103301244010210,100101031041022,100000240003101,102100010213413,100032224101400,100041234101100,101021410320100,102301000241011,103001220100000], + 101430402100011: [102211230244321,112121214040022,100004004100120,100041014210020,114204120210000,114110030002020,100000030100102,101012400320002,112002100233204,100002131000002], + 1000000040224432: [101233110040000,100001214100401,100200220110004,103102200210402,110400031000210,100010134202001,110010120020100,114020034010120,102001201130140,100000204310440], + 110032000232122: [114113014000010,101200210302201,102340101000041,111201222220201,100021014100123,102040020220202,114140204123004,114330004003002,100102001040033,112032020220030], + 222021202020000: [102133404134022,1302221400222330,130000220021033,1120023242400240,131114110030130,113000343131000,410120000124111,431000021231320,413200300004130,101310000020110], + 100130102030100: [110000001324024,101020000300112,103100314001030,101020111001331,100002020410020,101000001111200,114010040023411,102012220241003,102110001342011,111120214102000], + 231143404140242: [112024232302040,100040131021101,102040234002003,102000011410132,102321230240434,114020100042040,102020304012040,102144012001120,102101111341032,100001001002330], + 1033430430043024: [114004102300332,102020010200114,102003101131002,100010400101020,102011320233100,102240044042003,102120104000203,100010220021024,101024301002430,102003231440340], + 220104401200000: [101012131000024,102110141410402,101044001032114,100001111032112], + 114121103010221: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 1123021040432001: [100304201000221,100112021020320,103010001422020,102300124023122,114221004100020,102304100210334,100403210010142,112003100241220,102204304000304,100301104104210], + 1101300200023110: [100002100100210,102420424042020,100010001032223,103020031403100,102200401111200,102000430221040,114003104031111,100100000422320,100102020411200,102100012002000], + 120021012210000: [102201000240040,101141104002200,103320300114001,100101000010002,110240302100000,100033411000232,103021100002140,111024112200320,113110032411002,110002004410314], + 1040020000010410: [110040102001121,110310304430141,110301120404342,102113304130002,114032024012040,112000210210301,102012124012120,103002041402004,100000120201232,100031341030021], + 112004220004101: [114223204100010,102100104000040,112132434020310,112120224040040,100020004101012,102402000201011,102311011000200,111114200024112,114200024110134,100000020202030], + 100400013001021: [110441140102024,101004120224442,100413311002132,100320421001431,110210301200101,111131102210013,110400241240242,101001024210000,102210101121104,110023102103200], + 1030002211310101: [110201201211024,100422314300200,102141410230020,110020001224021,101021204000200,110003302000101,111122222240232,102340004011311,111134002210042,100013014300034], + 1142001133130112: [100422000031421,110302040102004,101402114042420,102220021120430,111341300012200,100102000010243,112410034040040,111302304130401,100024334203210,103031410122401], + 322000432011220: [114023002202030,100032024201210,100013401040442,144442110010421,103012134011120,100031030004303,130013324120310,100000010413400,100101132014001,100402230022321], + 1040010142002310: [101020024001041,100200201000001,112224232044014,103032004012111,100001404100110,110131022014120,112000002000110,101322221001300,114421204140122,101424044043122], + 1013040200402020: [102101004000411,114221312340014,102434121112224,100311204312442,100001024100241,103000020100131,101211204201231,111130412210000,100011300412123,102000004001141], + 1430400024011230: [100003211020020,111000240044102,100000101040120,102300000220000,102323320240010,100011200100023,100010044213301,100330204322010,100122124300402,103031114000000], + 1030012410100210: [110200220113023,103001114040201,111200042221400,104104033101401,102001004003320], + 1004040010200004: [112211122030420,102100012000020,101031201001231,102000010202042,103012240110400,112013012301132,110202421203200,111004410022000,102221241110321,102101320312141], + 101340211301001: [100410300030201,100132130421010,100212001012200,102041231120304,101020121032010,112100222300030,101302314220212,112013100212044,111130220024001,1000122140130010], + 202222000440000: [101133114022040,110210004434230,111100132241003,110100000020000,101134414020201,100002004302011,111424224422011,102301340200323,101000004210142,101340020341021], + 1000124124122331: [110013312204132], + 120030000221000: [110401004221204,111112000011222,100322444314002,101003301020022,100001030100030,112012004004000,112044204000441,103141100104002,110341300400201,100000104210240], + 1440432433001022: [110001022000001,110023342101220,100021004310222,110020422131120,100001000100000,112220322030220,110202222043022,110313312021120,100220214333200,110330234422000], + 123401430210120: [102142012001000,100000000014401,112023210242031,110243320110010,100022120412101,101002014013300,102100030222104,102120111021022,100400100022040,102303000242000], + 110021201324010: [110000002100440,102330031000000,102221410200012,100000204312321,110213401202110,110300121220201,100400440012042,112410022010031,114034424104042,102213224110010], + 1000130423410130: [110110011340130,100210304330211,111121210031101,101041010324010,102104210214401,100011230101432,100032024240322,103202224024200,114400044140001,114120010000040], + 122110440133402: [100023324302420,111121004103434,103111201422013,100212024121000,100001001033200,111121024400002,102001024012440,100033200000420,114010112330000,101304004232410], + 221210410134122: [110432001311002,100124004301020,101010011002124,100311010140302,111102004104401,103040104031010,103010014041201,110000224214210,110120100020012,102102030210224], + 102021110400021: [110101210013000,100404121014002,101240220300022,110120020002304,100011000202214,103040020122332,100000024100000,102200130202201,110012101102100,102102304001200], + 1100033000021100: [100022214203010,110310011234031,110123111300000,102001010240202,100003040002042,100020031041304,102120004000101,102020002000420,110100302010110,101220100303222], + 1030101231024400: [100031300002022,110210022120040,103002044002032,100101020402424,102201112000001,114211040011201,100020100423404,110001222202031,110403411244003,103000100114041], + 1140142023012210: [100143114233104,110400210100340,114200204000420,100410130034202,100112004034240,101410000304110,100204220431100,101011121032013,103024140100113,100131114030200], + 1002143002023200: [110140240121100,100420320432032,102200301120200,102021440221244,100300200142443,114110104002002,101004010300340,110210104242110,110413342122004,111030420024000], + 1002103001404101: [101013004000130,114014024101301,100130014030031,112010140202000,110010112030003,102001020220240,111310002200011,103402204002011,101042021121310,103030124044100], + 1123222240024412: [100122004300410,112400202020003,102000224000011,101212040303123,100030300124130,100001100013110,103122000211420,100032301041204,100410304320220,112030022303101], + 1000201004100001: [100114234102203,114400112311040,100231124320130,103040424010400,114203004113000,101141111100022,100000404100021,101332011001000,102103000310202,100123001012001], + 103202034314424: [101221020040220,102212000200124,100103104302044,101041030320401,102141212000200,101203121020430,100030010102102,102020004000014,100000211023014,114144014122041], + 110110003101000: [101240220300022,103011431401300,114102224000201,100022021041122,100013011020311,114021004100210,101040421033204,103130011441212,100020001041231,102100001400000], + 100201021044221: [102424204043100,100113220020101,100300211000020,114310200002400,103211220100010,101202201021310,103044004010022,114130020222342,112301032022414,102103100310300], + 100020022000421: [110201201211024,110123004401121,100040341020133,111101344104210,102203031121210,100410220030300,101110020013040,102032124001120,101021204000200,103313021402013], + 222004321004201: [102021100220120,101222041041012,114030234020304,114413200000230,114010024020443,100110300414001,111302002221301,121000033324102,100200203313422,112024201004140], + 1041114000211240: [114240012324120,102014140200013,101232001021020,101022011003022,101240101000020,100003101003001,102313100240202,101024001032321,102020010212020,100022014300002], + 120010100222114: [101010034002013,110001111011031,110021304203102,110400120400000,100203011004130,100114104000040,112401000200040,110010411100002,101201030303200,110101021201003], + 141103220011200: [111003204111140,110200421002003,102101142002021,100403304320200,110200024432011,212240000101000,100210020430111,102110211120323,100233031002400,100000000400201], + 1141420030040144: [100040341020101,102121011402000,110223000122030,110004010020200,100010111030014,100100121220014,100130204323304,101004111020023,102011302002212,114040100041010], + 111202434242220: [110121100004131,102320000221020,110142020400012,100142011022211,114230344103210,103114211441300,100004104241121,103123200222442,101303414220001,100131000400012], + 222011114102012: [112010300240033,114003234102244,102112434004041,112430202020210,101412044042002], + 102101402011210: [104232210210303,141111210002414,102000444004121,122013001001000,110002211101112,111300212011230,100401002201241,111022032202320,102100124003112,111000020023200], + 132311000000031: [100243401002310,100004000100101,114230014000002,114130104001000,101004000304012,100022210410130,114034424104042,112043001120130,114021214100300,112204111102324], + 130020114003021: [101400004022210,102031021441200,102301324112020,102140202001100,114404020002102,112102002010300,102111421342401,114013222204012,100011401030000,101240201014311], + 1140201020114021: [103001021432214,101002234002002,102214021120301,100404310020100,102103202002232,102300004112403,102100001001000,111320410010210,114300110003140,102130011411114], + 322000120201002: [102142004001013,101213240301002,100140200410200,101033040342010,110010000403030,100000224340000,100024020103104,110402101344233,114000212214022,114241224112000], + 1140213002004213: [114020000030002,102430401401200,100201211003004,102014002000401,103103241421322,114121012340044,102000400240203,102104304023201,103310300140324,100002224244002], + 102441420010012: [112133102012033,112014200224221,102142120202202], + 1004040021000310: [111011304114002,100000021023020,100100220423210,100231020112302,110013410002100,102000111441024,102001014002221,101110204004210,114240000000041,110004010004010], + 130014000323000: [111120030010031,100040204313012,102102002002242,110431012224002,101230331020012,102123402001200,100004244210201,114220320210120,102420124024204,101002030300111], + 1101331000204240: [112224111100141,110113314221413,100040134340044,112004310224204,110422201312402,110302011332024,110200302024000,110210020104031,110240411110010,110001000142403], + 1010003001321011: [111240220002100,110030344201413,101001014001021,110100001014311,100103224301304,114000100020200,102102100231000,114040202330200,100410331002222,100032204311200], + 1040420003042020: [100032041021210,110004301222000,114310000001232,111202012222402,111322234130000,102040041320010,103203401400132,110104002010100,102042204000300,114142044120310], + 1110422101320111: [110322022102000,100032201233122,110310004424040,110101020124104,110211142020210,101222244040110,112400124013132,102013421320121,100001144314023,100201020431003], + 101430122140014: [104441021202022], + 1030122120020202: [110220100000102,102100321320100,114042102330002,102102011414242,100041004100221,102310030240210,100000000412112,110000010033022,102210000201040,110110122210000], + 200120020304033: [101201104041401,101402011014002,114410012310230,101423011010400,102141100210112,114130200001000,100022224312021,102122421340210,101011104014011,102031134010020], + 1021400330110023: [100041000411231,100004004100120,114204120210000,114110030002020,101012400320002,112002100233204,103303001400240,101201000300222,101200200301000,100000004214021], + 1100004223202210: [100400130013111,114101034001001,101002330300101,102100004023000], + 100242034400003: [111120230020122,114301000000002,112124310203104,100113324103000,102001000221124,114040204014042,101010111033143,100021221024312,101221031020331,114301120000200], + 222000021300204: [100024000110221,102340221000300,100110020031042,110422102110221,100402002201002,114130014001202,110010220103020,101011014002032,111004100022110,101002201140040], + 1030010441100031: [100422004320024,102420031111001,111000022200230,102300011002030,114044144020400,132202000104100,4000113102314022,1002001000001021,113120400001003,1400100000042343], + 1010000113002104: [140420100400012,132110011201141,122012440110401,103211024020021,102010021101114], + 102041402032001: [100020400410010,102103441142340,101211210304010,102100001004041,100000414104102,100001020044101,410310420012412,441000221120012,101000020100020,110002011202022], + 1200200024003120: [110222020012300,100432200033101,101230004040022,114244120001041,101021020324310,102120111142201,110010011212411,110102322040111,103230010114302,110010220000210], + 1100000443200001: [100032041021210,110004301222000,114310000001232,111202012222402,102001301120112,102040041320010,103203401400132,103142111441040,110104002010100,102042204000300], + 1200124421020013: [112000001121121,114101222204110,100244340430210,110010104412000,102204424030220,112401002021204,110002112102110,111003410011000,100200201001120,100400100022002], + 1024231012020003: [102112201020000,112220102043102,103042000110130,100231200100003,103224224022200,111404320001120,100123010402022,111222212223204,110320000110021,103014004000102], + 1414000100020040: [101030310322400,112100134020020,101211411020304,102132200312222,102003124002023,102230320201000,101042201140102,101000320320031,100201000440110,112432002023000], + 1020140142020211: [102322014113341,101022104001221,100040201012040,110021422000000,101120030330110,112021004003303,110331012224112,114100222310230,101002200301130,100011120000004], + 104000211010004: [102302440220001,100104400403240,100020111221020,110010122102321,110002322101200,102220124000003,101020201003002,100230300001042,100311334020020,112400022020023], + 1100143000102000: [100000101040120,102323320240010,101022344002202,102112101020021,114313044003041,114024222212420,102410000230114,114201234002300,102303320221102,102120104131410], + 122100200040131: [102141242001000,100121124234400,113000110124020,104144130014121,100130040002001,112203042030000,110114012012120,114224420001001,100120044031042,101400021103310], + 1111010024431002: [102412004000132,101233341022410,103013314020203,110120211001001,100300400142001,100000120121031,114211324100004,102002000222021,110201030143012,101124211221020], + 1220001020202200: [112312022021021,101200101021000,103000024014022,103122104002013,100040404102010,101020404210020,100121331044301,100001001021002,114200104001010,114040414014202], + 120002412412012: [102111024000402,114321002320001,103220011411101,102311120222404,114020404020132,101220111023331,114220014111304,114400202310013,101030301000221,103313200113023], + 102100043000101: [112240102020420,101002020301320,101024301001431,102200020203020,114220020213122,114201122324130,103003230103011,110020002002100,114440320000003,111040414402121], + 1004010322144031: [111111202220201,100100001040040,101320320300220,112022102342404,100020024314033,102212341122000,100032101030101,100430200420000,112004414002210,100020441001221], + 1042102002210000: [110232002101410,110331400400440,100424331001120,111040300024044,114021112203114,114000004110202,111020232200302,103124000104424,114411120001020,100021020414340], + 1030400112042001: [102100201440001,110400011311001,103300120141130,102110004000221,110040002132020,111144202220301,114224204100310,100000000120200,101434031010012,102304011004310], + 1002120204002020: [110000002100440,110203120112002,102330031000000,102221410200012,110422010000200,103112021442033,110213401202110,102300104113403,100400440012042,110030231214100], + 1432143000023104: [110042112120300,103120031442112,101003101032341,100004121002021,110223100100433,101002310320000,111120022212034,100001244311023,100003000000440,110301200013443], + 101103220201313: [114200004002011,114120320224032,100001221000324,102300434110242,114030012303012,110202024403000,100300104101111,114213202341241,110002120020011,110021012204100], + 104102042310320: [110301442021010,110001332103022,100104004300024,112041000220020,111304202202230,110000002001040,100430440030020,100100124301211,100110004102340,101234021200040], + 201031330012004: [100232214222204,100040324331403,112104212010101,100001104201201,102300221002020,100002101020010,112010202000202,102033024010010,100004001000211,114230112330402], + 100031010300000: [110020000440124,100122211044424,103432211210302,111120442100320,112201401104040,114312112320302,100020230104020,114110412311002,100212324104022,100230000410021], + 100141002033100: [110212022124220,100003100410042,100222034340301,101440044041401,111210012243010,102130124000000,102010421413322,102114020210302,100001100100040,102113131343200], + 121010401221010: [114400034122341,112021201120101,101000104002203,100000121024021,102101104000212,111120010020104,101000011111400,100020004212223,112030021111302,112101002304200], + 1001203000031110: [114100300222100,101110111104231,101030110300001,100004101233003,110012002000010,100021220000430,101120030332424,114330102320220,110110422011432,102143230310120], + 100103120242031: [112131014040114,110000202000043,101012120300424,110322020011332,110304000102141,110021104411410,114323102321122,103100000110030,103014231241000,103100421241010], + 1010000400010000: [114300020001420,114133230000102,101021120323020,102234010200304,100001021030011,102200100204220,103200110102141,100021030100001,102203301003030,102334201001100], + 1000001200132004: [101220014012231,100104024303320,114422004110130,112210132031001,102012030213014,114021114023402,100210004343102,110031200023240,101000140310132,114242312322020], + 1202012002010210: [100020331001310,100402010022123,112040411110201,103320130140000,103120300211022,102201012022300,110141031320010,103202111411203,112131442302432,110013041300140], + 120020010110010: [100000131221101,110001010443143,100002020004101,101020324011210,113430000101010,100110101022034,110122320000230,114300220013421,102023021120102,111030040020222], + 100140330120400: [100011211042100,110421001213004,114210010004202,110110211240001,110300410010340,102010004003021,102000121101004,112034122000441,100000010000021,102031020222014], + 1004200023014104: [100002104302320,101023424210024,110031024200343,100110411011010,100021244103133,111230424101321,103102400211002,104110202100102,100113040414312,103000030101020], + 203030200201120: [101000041142321,110430002112002,114312022300401,114000320000040,103000111421112,100110001000423,111000000041000,110211010101001,100403132200002,110042002122001], + 101241202100004: [103301244010210,100041234101100,103001220100000,102401024020221,111231012242301,114444004140210,114114100214000,101104320012044,100000120120001,114210224102122], + 111010310114321: [102422114040010,101204400304011,102020004001311,114103212312012,102002034010400,102020030220401,114231212342200,100020011043020,112022200202104,100040211031313], + 1000430000424100: [100034011042140,111202114103220,103000121421121,100200241001404,110400302222204,110310011234001,111020012233400,110013024421020,110001002010000,112201302024400], + 140310203002140: [101020414010211,101120204002140,101142004000232,101020024002022,110120011002420,112002112002220,100012304300004,101011421140423,100400320013200,102041314012004], + 1040040200104102: [111131224100212,102010104000341,114120100223000,100404010020000,101240000302141,1204002112200213,110010302002100,102101201121000,101100001111040,110031222130200], + 100012002010000: [110001422030011,102144314002302,114200112340002,102343014022001,100211000430431,101213240301002,102240320200212,100140200410200,100020020120200,110210001214000], + 110132013420040: [102111000202241,103232220103211,103202404031100,110043132100220,102022004010004,101201114044200,100402002200010,112234224002101,110040304210001,101002104042030], + 1000020414030102: [100002014200331,111020032203301,101000210303342,101440400302320,101012220323021,103000121424330,102111021022024,101012204221200,100300114310112,111100020020010], + 1000020100000131: [102100321320100,114040102210432,100034004211240,102330040242220,102140121410131,101201340300430,101241100301411,102002140220202,103000101414111,102113111343110], + 1000200221201210: [114020000030002,100201211003004,102014002000401,103103241421322,114121012340044,102000400240203,102104304023201,103310300140324,100002224244002,114310200002400], + 111033202401014: [101213114040141,102210101002412,111140100011101,103220120212134,111103314101000,100012011022000,114140104122430,101100010302233,102100402004002,102000111102000], + 200110003102100: [110120144200000,114022412330004,101200221022044,100103104302044,101041030320401,110241112020204,100002004104004,103130021444021,102100104002224,102100224000210], + 220030102121210: [110000002100440,102330031000000,110422010000200,103112021442033,100000204312321,110213401202110,110300121220201,100400440012042,110030231214100,112410022010031], + 1000122414010222: [100100331000022,114222040214020,102032000223300,101000441140230,111300214121201,100234124120220,102204004040300,102202021303043,110132124400400,114112014003202], + 1042041012104000: [103130021444021,101400004022210,102031021441200,102312301104422,100000411002023,102303200241200,100022021041122,101200121022000,114300234001100,102202004013101], + 1004200403121111: [100130320031042,103110021442200,100042001020203,112221200410000,112023032000020,114023224010002,110020320412002,100010330101003,100002241200002,100013014202033], + 1103000224014244: [100002020100002,102110410200214,103102000100210,114140004123401,100230041210111,102201010200001,100042001024000,114142200031221,102012400223014,103233140101001], + 110203023132110: [110041030411301,110001041213031,103301210142043,100002024200142,101110044200100,102411000200000,110414300030001,100030020011022,100400014321101,114100122342002], + 1001021200001012: [101011004212201,110032022002020,100214230430124,103031234000122,102044021101411,101100104002023,101042001021012,103230011412301,100102001000000,103400104003420], + 112040032301204: [102330004110200,100000004134002,102220014033403,111202404440010,110100331001102,101020031001112,112422020201002,100100001202011,114104030222003,102320241000010], + 211020420204001: [110301011234204,114211102321011,102110221412210,103330421400224,102000200201422,102412004022002,100032204200023,100023211030203,102104301004310,102003014001002], + 111023100130310: [100114004100001,102012030213014,102003320200411,102002024000132,112440114040203,100401001011010,103001204002010,100340114211043,100033001220020,114233002340141], + 1110013403420040: [102120010200131,102312300220000,102022000220004,110020120041030,103001220104301,102004004004200,112010004020300,102201001120441,103012000121000,100240204101020], + 120300301041010: [111112002210022,103222004002001,102024021130010,112012010230002], + 121110220221411: [110213100122010,101212101023221,110213001300231,112120222020002,102130100222100,110200204432001,102020411123201,103024041421002,102200034042002,102030004010204], + 141201013131204: [103112010213010,101212000301013,111400002102112,100034100124302,1320102201231021,101010120320311,101201101001302,100000211020034,100020301020200,112201011040200], + 1141320221124410: [132040114102000,100134200001402,110000012011021,100102204232003,111024004412100,132220204100102,101032103444021,111314020011311,101020021121012,103103214000212], + 134403004204110: [110120144200000,114022412330004,101200221022044,110241112020204,100002004104004,102100224000210,102310140240012,100014204201000,102103321411004,100400001001300], + 131000000024121: [100301224310100,103002104012101,103220130211414,100012324202240,112101102012030,110003410100312,114000022300301,114000000021100,142100040004101,101030340343012], + 1404322032320021: [144131233204044,120130001004000,101001131032132,110400010031401,102220211120002,114112002313010,114014010033321,101400104042212,103441112000230,100010030100022], + 112240042330120: [100212201000030,110020122101104,104130030010110,100001134302201,100000010411400,100000140413200,121010220004000,114042004020130,111120112103420,101002304210122], + 1402040020000013: [100022001030013,102100300210133,102100031340024,102012100222101,102233114003301,114401200002300,111000320303042,142014000003120,121010010000004,144400100020120], + 1000104421120012: [100021300101110,103010301402112,103134021420204,110201031111320,102024044012212,101012144004034,101011024001430,140012010401001,102011204000211,102002431120001], + 101324212100210: [104120011242011,114300000000002,110020002104100,110210014220001,102111400202120,102000301101102,111400214442024,114100124002210,111122200021102,114032234033303], + 1012000103004031: [101000021010022,100022310120003,112004031122404,114341322301120,100040234212230,102210214110002,100020204103212,100000100104142,100200024301424,100101344302232], + 110031110000101: [102021401410001,114210410000401,102002410222340,103210214003143,100110000020111,114401000004202,100024104100032,103303000112122,102100014132110,100021304103002], + 1140200100100424: [114110000002430,111220014133002,112111010201220,114013422300032,111304104130300,100131414303044,110100134403210,110101101120302,100103004232134,103234200101200], + 1140040023010000: [100010030100011,110301120404342,114032024012040,112000210210301,102012124012120,103002041402004,102103030210003,114010112332112,114121304121000,102221024044110], + 131202102303031: [130310130330100,200224331000220,101231031400202,120412000041110,110231402124034,102000444004121,100400100013010,100401002201241,103441004000230,112412130204022], + 1141004132323413: [100124004301020,112042012000041,100020034311000,101010011002124,102331201001312,111102004104401,103010014041201,101100401102142,102212004110012,101011420301002], + 1422011301000004: [101012324214020,100000041041202,100000004214210,114230000000202,100120010020214,122202200013331,102110211441000,100402110020100,112000320221241,102100120311400], + 1040342130222022: [100130011012003,110200000104021,100000020000020,103013010120103,110010024201241,101412304021202,102100021000120,110211124242220,102013001130300,100103234102402], + 112210302401020: [110300221220031,110201220000032,100021214313034,114300200000110,102011224010041,102000021133001,103032234010002,102301434110030,122011001202102,102100301400242], + 1211322041232002: [110113314221413,112004310224204,102304420211002,110403042110030,100032424312011,114112132313033,102204010204023,100220000432400,103011024000103,110100104220021], + 1041100033004324: [101221020011201,112310132020030,102031100200300,114102134122020,103122011241020,100011101011002,103010034004303,102101440201242,112002110240403,112214410201300], + 1040022141202022: [114031000022030,102014002000401,103103241421322,102104304023201,103310300140324,100002224244002,114310200002400,103211220100010,101202201021310,100021404301132], + 1041121002301104: [112230122030224,100110130000123,102030000221134,100210304340400,102201032021231,100010020003310,101042204010110,111200332222140,111201314412204,102000200204141], + 311002012043100: [100001200100232,102014000220330,111000042230334,110011000112024,101024304211100,104134400010204,113021021010030,101013214002010,100111011200111,110000122030202], + 1001331303210041: [100003034314200,103300040140032,100002301040000,100002120010042,110020302100200,110042002002040,101403240303041,100002101231220,102040424014311,110411000101240], + 1003240040420201: [102422114040010,102020004001311,111201210000103,100101101010100,102321044112101,100022024100041,114231212342200,100020011043020,100021231020200,114201112322020], + 220421130000000: [100102110412002,100000204214001,102013024000211,114021004011100,102140140310001,100402022200102,111010302203001,102110111023103,114100102341011,110032020111024], + 1100101424021021: [101000024010001,103204214002340,111101222101212,101214134040140,111002304411031,112404322020241,102001310224010,114000224102000,100112034103110,100203200030344], + 1410200010010004: [112202402043330,100000224200100,112030112000014,111243044441200,112123120220000,112100104042330,112011020224211,103123304023003,110400140001004,110000312130002], + 130002220230300: [102001404012100,102340120222440,114223204100010,111041202200140,102100104000040,100023014313010,112132434020310,101040100302002,100020004101012,102402000201011], + 104000202400124: [100232121210011,112022200234200,110043132100300,112230000412212,102220120203200,100002004201122,110132031134031,102022140202012,1220302241034202,100240200430040], + 1420021002114341: [110022000023010,102410141403032,114221002303200,101004104002142,102101210234111,103110220120102,102303100241021,100100021010323,102221000202231,102330301001210], + 1022420232012024: [102203301123001,100000001030003,114030314123101,114442222312000,101001001030440,114000024014200,101002104002034,112203120410003,112100024022001,100000404201010], + 1000303304320420: [111443032100000,100010314103002,100240240430022,110310321232001,103221100112240,112000000211220,102323131000021,101020024210020,102000110221011,100000024300300], + 132304132200000: [110000311220202,102104004001013,101422101012041,100110034034002,100240441002203,110242301110320,110203002032124,100031130423104,110000112002042,101124004002042], + 120004001023023: [103201300110101,110204002121413,102144020210132,110420040000002,101020011031033,102120001144202,110003040140004,100210030001420,110021041310010,100030001220222], + 123001231420004: [101004100331003,112131222010010,103001011400102,102000011102134,100002121032011,114122224003201,112034022311032,111001420021111,111100214400041,112020102002024], + 1214020002302024: [102402224000010,101110101110020,110130001120000,103112004000401,101020221030424,112000020242400,100000300000301,114102022310302,101032210301000,103011304042031], + 1024204110123001: [102010021321412,101003110303011,102400204001110,110210300000100,103000024040000,114000214100213,102101210200200,114010130043021,111003302140220,110000142001210], + 1101041214020210: [114002002300004,110100201140241,102020111324200,100042204102400,101044400300030,101024024002120,110203002102023,103442121212103,110214300000010,114021142300012], + 130330034114221: [110102114204323,114021140030020,103124000104424,100100201043042,110302012103034,110130201011011,101000304212200,110001020120322,102312034020114,102331001000120], + 131402002312030: [100430014323000,100212101003134,103030014000020,102402201110020,102022411100012,100020024100324,100001210102104,101230011020020,114000020034200,114010214032000], + 221122012030020: [100031300002022,110210022120040,110000021221134,103002044002032,100101020402424,102201112000001,114211040011201,100020100423404,110403411244003,112030200222220], + 1041304021421031: [101221422120021,103001024002110,100231114320100,100001000002210,100400320033201,110011402100202,100004130002301,101210300302302,110100012120201,102020131413423], + 121020431124002: [110220420000100,103132204001001,110032234211211,114410010001200,100400022200200,103024400110044,111301032200412,110100120120001,103120101240000,111041120040000], + 131430242240300: [114012012330203,102100020211003,100000214102101,111222000012010,100000004100411,102413124042401,100100104102000,111204302220322,103021024022122,101000220311120], + 101000112143010: [110000102100303,110001020440110,100044021020010,100404202201012,110400300000102,101002244002110,100144221000002,112120102013001,100230104224024,100200004102020], + 1010411230303322: [114400034122341,101444024041143,103020001400040,110200332041001,114004020010203,114002004033124,103030324000302,100203030110000,103204321414213,101004200341000], + 1200300041104031: [114400022321400,100011101222101,114304212302401,110021324200010,100000014201221,110200030001040,102312021101141,101010001022001,100020111222204,103101201242022], + 120000140100223: [102240221000001,112202412030001,100010000101004,112410140230303,114210142321120,403221301412211,100040201022210,114013022304300,102434044043420,102122014134004], + 1102320302100420: [110040022130003,100030430422242,101120014204000,110014300001402,100100014230110,110201004241002,101000131142230,112001204023241,100104044230000,114022024012213], + 1114043000110300: [110441140102024,114100200002120,101004120224442,110310020040401,104120221240413,100413311002132,100002024303323,100320421001431,110210301200101,100202024123224], + 204104320213021: [101004120224442,100413311002132,100320421001431,101233021020010,110210301200101,111131102210013,110400241240242,101001024210000,102000324010303,114002020042033], + 141014003400220: [111102004100101,102021100220101,100230120001003,114000040010421,112042110220004,100000214240410,100433201004014,102301102004413,102003000220111,102010100204023], + 1012223100414200: [112142301101040,101100000330120,101214440300301,101121100332142,112401314040311,102011004013000,111200122222334,100220124221000,102301024113440,100033230420102], + 122101010421400: [101304020313003,114300140000220,102001004011002,100003441020101,110410442220020,114000012210030,111310022200240,102301044113020,100010220001020,100100011000040], + 1101211002242100: [110200000113011,102101001340020,110002202130110,102032114021101,102110210230401,101040040322202,101422244020101,102142120224022,102104100233030,101210010304011], + 224000010120441: [100004211221210,110403221000002,101201304200320,114022042302201,103310101401010,102404042001400,100020200104120,100101140102400,114122000000312,110310312103010], + 131331044101012: [111102004100101,102140014001101,102021100220101,100230120001003,114000040010421,112042110220004,100000214240410,100433201004014,102301102004413,102003000220111], + 100212023330020: [111022010020231], + 1044011000001442: [112020104001300,101400110300032,110032412204130,100101004300200,111032414402324,102424040202123,101120244000002,102110024001402,104240102023211,101103344001200], + 320030132101142: [114401200000003,100241001003002,111310004122000,101221000312044,102030300224002,112010022000304,110323142102300,104124002103241,101002211110002,112020402000012], + 101100201200030: [100021304300200,110321031234422,100020020102201,102023001440404,101023014004000,100020010101201,110412042010210,100100214102200,102103000233434,110124411120222], + 1100321212232104: [1440100023013130,401210002011000,1014200301032410,1001102321230101,1103013112041021,110200024240110,110431004224201,400014401213001,121000110000222,103000001421223], + 133443304212300: [100020121020300,100002201032401,100240010430203,103432001210300,112440134041000,114300100002210,100210240013000,110401214242400,112320142024331,101044214042221], + 1012021200200101: [100021204100204,110211020000002,103002034034022,111230214102412,111433044442220,101000004013020,101013320300001,110041341300041,111022120023311,114110420031102], + 1011034222001011: [103111001422000,111244302220204,100042100102211,102110030200120,101114000332010,112112211102024,114001032300011,100142044103021,114004014011110,101100010012423], + 103124122412300: [102000004002101,100422314300200,101403014020203,100402004300002,100042030120422,101134224001001,102321234111310,112100000200031,110003032000041,103300234023033], + 1034002000100214: [110003000042343,103001224014142,102304000241010,110011000043131,100004220412332,114102400001020,110220201301140,100022221044012,110312300010200,103214210103210], + 101340000102440: [100003000100222,114002114102311,101104201112142,114001020022140,112000000241003,100010411222302,101223004013001,103100420210020,101100140332421,103300001403202], + 1110430022000012: [110232022123020,100002004303100,110130010102101,100010240101221,111000122201420,102000041101100,100042004301301,100012021031014,100000201032010,100404000020000], + 144020003231311: [110020402002300,100000004102242,102311011001213,102000020223021,112024101112213,112003112000011,100010000013012,102140004030412,103000304003210,102010100223430], + 1430101000322123: [111304340002030,110102000401214,100100111044040,103140014002031,102024102020000,102224241110003,112003020220120,100043024210301,102014001130100,114022100010000], + 1124240400140003: [101101004003402], + 220133002430202: [110202210102120,114001004100003,100041014102004,110320022101120,102131421000411,101412030302001,102222021124112,114000040031021,102400001110113,100404201012020], + 142302003130020: [141401003011030,103120200123001,100301314104023,100001140421202,114400420000041,110044002001100,110024222100202,100040014202402,100012004101100,114142014003220], + 110004222301024: [114102312344021,110011212133431,100012340404402,103400104001202,111000022140011,100021011231420,114012014101002,103020400122301,103110120123010,100402400022001], + 1002332222012001: [110323002022000,114000024021000,112410402020100,100100031021211,110001321324002,110003422130430,111212024130030,102200040232103,110010001320030,111234102220023], + 211211012002000: [102302200210010,103100221440010,114003344011001,100021101000000,101014201030204,101203001010111,100031201030102,114201104114111,101041001003300,114012444020220], + 130121221100121: [102403001342000,100102431021300,110200212041001,100033211230014,100001211040232,100100024234021,112000321112201,104122102100220,112034300240022,102213204040044], + 222320411422040: [101302134233230,103220011411101,100000130010033,101030404212000,114220014111304,101030301000221,102003111413120,100020001042002,114200122340300,102013024002300], + 110003024002002: [101200101021000,101430004040203,103000024014022,103122104002013,100040404102010,101020404210020,100001001021002,114200104001010,114040414014202,100000024301031], + 144233123220212: [102111040210242,110004202003210,100424220032043,102021004001004,100131414303044,100000221030033,110101101120302,100040201030342,112000012000010,101012201030310], + 100144142023312: [102402024000034,103012024004312,102214020242110,101140320330114,114234004000210,112120020230024,100000204100304], + 1401112120113103: [103101014000001,112430102422123,102110000230003,114123142314300,110401222110010,101012131000114,133111102100143,100004101032211,103001010120400,112201012032000], + 1200012024440220: [110112102211042,114314300012000,103004000112020,114200022300033,101400220303133,101420010300310,114112320020021,112142012302100,104100001240034,102120210322300], + 1112013310203113: [101210331023020,101011211002010,104110411304420,100222100412022,103200004024040,102140002000412,110043001201204,103420334000103,100010214302012,101201324232020], + 342020223401220: [103100130122100,102340011104001,112300002022101,100430101012411,112013212002212,100202301000000,103411014002010,132000110000001,101000000300110,103000204004020], + 120120200103000: [100002100100210,102420424042020,102200401111200,102000430221040,100100000422320,100102020411200,102100012002000,114221030000011,114200302341234,103002110100200], + 200421114302210: [110102114204323,111120002100412,110302012103034,110001110001202,101000304212200,102113100230021,102030100221011,100420321001400,102303401004200,114000304031102], + 240404121042414: [103134014000340,104103100010141,111101222240010,100040210411102,102010000221204,100110004102034,102040140220220,114010400014304,114300132321233,110000140032001], + 302200144024114: [101220014012231,100104024303320,101010311003410,112210132031001,102010310213001,114021114023402,100210004343102,103422430124013,114242312322020,101000140310132], + 1121404401211212: [114120014120230,110000100422111,114010314101200,101001201110100,102341014010003,100310111001140,101000030321400,102400014020400,114322134002204,100002320104400], + 132040041010323: [102000020223013,102310111001210,102100121341102,100301024310020,100130010101430,103112000210401,102113121401222,103020111400003,112011041110422,111230014100320], + 101103442222004: [114030110041300,100010400022200,102300001002144,102302444110110,103001000142003,110310004424232,112013102004422,100400220013232,110010002000100,100402012200112], + 103001402200022: [101020024212042,100041204212120,102113110210240,112423424042102,100320431000002,411200101402221,100120214230002,102440100200000,103204200103440,100210004104001], + 1000022202013000: [114113104123200,101210210300031,110002021121023,102300040221403,102201100200430,100114021040000,100021020412110,114201204111002,114011022211140,103000210120000], + 103410102203120: [100434000032200,110004020020022,114032412303041,114322024034312,102040010200101,102200434012013,112000301122111,102100201400122,102013120200110,102020130212402], + 1011244210020400: [102120300202121,102134111410122,112204022020043,112110112300112,100410124102101,100222300434012,103003040112031,100002300000243,100120021200321,114001012304000], + 1020402102024013: [102031000211000,102100000214320,114211132343224,111200044424130,102331214112200,112003102000220,103014330110310,103131211240031,102241010230310,111001010020044], + 1121404022003104: [102403004042342,111122004101222,114020040013100,114000222213021,100000020401302,111001100020413,111301204111233], + 1004422020010020: [110030004200002,112031110240010,100100414230101,110134022013042,100001000000200,101034401033340], + 1011412400400102: [110001332120300,102101211411000,110003000420200,110243234240200,110004014411012,112000120232022,102041220200010,100002320113100,112240200202201,110020321120011], + 110321300002433: [100003211020020,111000240044102,100000101040120,102300000220000,102323320240010,100011200100023,100010044213301,100330204322010,102111211401000,100122124300402], + 1223421020002121: [100001141020100,114220044111204,114000234011323,100020104312001,100000100000104,101121121101124,103102124002001,101003200320102,103312304020314,110110001000304], + 113214012040101: [101010241003223,102000020220000,101100300302102,100003044100101,102034221103124,114012402332300,100014030200221,103030201434002,110204314402021,103121004002210], + 102012011001200: [101221020040220,100103104302044,102020004000014,100000211023014,100201111002224,114242410001010,114202044111100,102013420220240,114212100211223,102102044001132], + 112002310310000: [102411111400020,103002100100400,100022110021010,100000014100240,100122044230200,303020114301043,100100030200200,102202144030212,103031204010122,132044134324300], + 1401100100301010: [100200104321000,110000110410110,103220030101023,401300041114001,112032302000220,112003000230001,102004301444000,111133030010200,102103231340304,114000044101422], + 211202310000000: [103140211443110,112200224002440,100030001020201,101302401003202,114320100002004,100012200201130,110203221112042,110002114410102,114330100000020,100204220000112], + 1100220021000203: [114033300040100,100313030142202,112021201120101,100001000012021,102010231120312,102043030202102,102300014110023,101021110322104,114420302320210,102103422004103], + 110020000104402: [110201100100220,110033322001424,104100202101022,100041230102210,101131141042121,110012012004102,101320244221142,110340310102020,110102431303010,110424014243001], + 1000220043212100: [102334004110232,110311331003000,112200102024122,101020240300003,103000034003300,112300032000100,112021334001000,101000100322140,114010010002314,102321040213311], + 110213202022200: [120200102001400,102001034010113,1300102201211020,101313330340001,1112301032024000], + 100142100320400: [100004402212111,110214202044002,111003002230111,111111000020303,111000214410000,100120101204130,111414402100001,112141002310411,111120140012242,110101241000202], + 210020140240103: [102322014113341,101022104001221,100040201012040,110021422000000,101120030330110,114100222310230,114131002342130,110002022003101,100403122201202,100100220403100], + 120013402303143: [100032041021210,110004301222000,102040011121100,114310000001232,111202012222402,111322234130000,102040041320010,103203401400132,103142111441040,110104002010100], + 1020011101210000: [104244002023000,120133001040211,111320124130040,114012412200022,110000110000231,100142041012023,110000000411120,110302100010342,101301030313022,111440222100012], + 113201442210121: [101003040320032,102002420220000,100110314300212,110022302102330,112032314000320,111012024112012,112101204022303,102002300240004,101042304001201,114001002300131], + 100102120012432: [100312331004000,103301244010210,100101031041022,100000240003101,103001220100000,114124420032020,112012012002100,102314001000244,114100000031020,103242004031022], + 114132400024302: [112102024020402,102102010214442,102101211410144,102010214000120,102010111102410,101000110322242,102404110230202,100010020101222,101222104010140,102120400200312], + 120314241010120: [110012010410000,114004000023341,114021044100401,110201402120213,101022040300420,100041011221411,102110010203021,100310004100403,101000000300302,100010301034103], + 300020040221203: [120133001040211,112200431102021,111320124130040,110042234410000,110000110000231,100142041012023,102030200222404,110000000411120,111440222100012,100420111002101], + 1024304020010121: [100240000032004,102000000210211,111010204401023,103142444002002,101200010300001,102211300204221,100301004321221,100020000410313,101220200040320,110301111301101], + 100243021121232: [104110021244203,102224101113104,102103022002001,102102224000012,102100102001032,100142431013000,101000031001011,101010130321200,114004322330012,114202144102100], + 1130024101421004: [140203123020300,102010011011210,114010230023434,144203403221310,102013131134030,100110003330122,103312010110013,141000201412111,110004030120020,100332121000004], + 120001022414041: [100101101020002,402104002030100,100010044110040,102113034020402,110141200002120,100020004101340,110100111221402,100104100414031,103202320101211,112000212001200], + 120030020023201: [102010244010000,114430412322343,100000430014301,114423002314000,114010134021022,114102224104002,100040240003341,114422404110312,102403144000120,110102211300112], + 1114101000210042: [112413224040101,100220100110400,101200031020230,102403004042342,101024001034211,111122004101222,114020040013100,114001012300002,102121100232012,114000222213021], + 1000000210200002: [100422040021304,111111000014001,100021320123031,100014041042003,100002010413410,101433010300204,102114321401000,100002414201103,110324444424432,100122234300420], + 120000200102214: [102231130213210,102000402041014,100043324210140,100023024211011,100003201021001,110002021121023,102201100200430,100022010411004,114121300224141,103112011421222], + 222400021410223: [101011100300202,101000030310000,112202230200300,110001040112100,103132001240124,111040000020020,101224424043100,113000132200300,101042100313010,102031320200104], + 1140024013020004: [101000141031222,102000421131000,114404020003022,100421242201010,110200200001000,114023024101231,101410114043204,114241202320300,112431402022004,131202034021212], + 1203100020210011: [103242420100012,101400004022112,100100210000011,102200000200201,103110020210000,100022141030334,103200211410311,102100404021014,102303001102431,111441004421100], + 1011432344432402: [102310324112030,100410130030232,103220101421001,121110020100002,100002104204000,140004230143221,144200400000000,103321202010002,101124344200400,102021220202100], + 103220021012001: [102010114022011,114002200000421,101020321002002,114302210010001,114030004104220,100104004301000,102443211401140,102301041000014,112142011101404,100001111201214], + 122224100040443: [102110140224010,100103240011013,100020210101002,100042420003120,101020120322020,103130004003141,100024321020243,110112410431040,100100031002000,103000244010320], + 1041023033141201: [100400002201113,102420424042020,102111024000402,102001011100100,114402104142102,102311120222404,100100000422320,102100012002000,101320224220103,114400202310013], + 110201000401012: [101011000322203,114421102322111,110241022112013,102110010230101,114423004144120,112001102000201,103014044010100,101012200340110,100210331000030,102242004042400], + 1210210410110322: [102300001002440,112101120201010,101000224223002,112240000413000,102012011412102,101040201112304,112422342020141,101113004000203,100100301021212,100043124200131], + 1000000010000112: [101203004040100,100142224230113,102104131122031,102320024020040,100021114102210,101100000320132,110402122111020,103040120000040,112010000211002,111041012143402], + 1004310000212110: [114021412213020,110030002000422,103100014031411,110000300424304,100032121024110,111403100030130,102022400211311,110030400004330,100401241014100,102324410243220], + 1023102031400100: [110141010001110,104122011242020,110213401202210,111103310001234,100110441001000,102312000240002,101202124010000,102012104010301,114123014001020,100004004303030], + 1030122204000210: [102400111402142,141030301403400,120402022102021,100000024100211,103224200113121,110140101300004,114400210002021,103103221421013,120020211120020,110230010010142], + 1020322310430300: [100023324302420,103111201422013,100001001033200,103201000102140,100033200000420,114010112330000,110333034433002,102343044111203,103231001400100,111122030020244], + 103100004000400: [111300232202103,110122120100022,102400100220000,100242444300104,110002202001202,110200422113400,110022300021012,112000000223310,100011200201230,111001002201034], + 104000230200402: [100030220410304,101133040012001,114000102210140,114032400014212,100000300012003,103142211213001,103002040120124,110302102000120,103210000213424,112402114044002], + 1104120010013212: [103324024030212,111022412140224,103030304021102,114110004121301,100222100402024,112002220220002,100121301023030,110000130020003,103002144001000,100014000022201], + 1112004022112022: [110201021201020,101111120330403,100101321220213,100120034230102,100340011000110,222400011010100,101030010320010,111101010011204,101021300320314,101002120320124], + 121241200402212: [110401004221204,111112000011222,100322444314002,101003301020022,100001030100030,112012004004000,112044204000441,103141100104002,110341300400201,100000104210240], + 1010324010403033: [110033100114102,114330004030120,102410101111403,102310140211101,110030000021420,110001022121214,111120144101403,101021400304200,100024221230411,110230000002421], + 110203200000220: [101220204040032,111003044110202,102230231120222,102330304110101,100430021011031,102330021103040,103303031404000,111330304131300,100002131020340,101202221022030], + 1030241201030200: [102210100313100,114113014000010,101200210302201,100004420014012,102240210240022,111201222220201,100102001040033,112032020220030,100002324211100,111231042242020], + 131102024010341: [110110132041402,103140240112020,100004411232040], + 101204101201001: [102112200201012,102321104111003,111111004400103,112100022300110,101003010340102,100200410434002,114104002204400,102004221132241,100010000002102,100414300433033], + 200202134410101: [110021000410432,103202000110102,102020440220202,101010010320112,100042000000000,112000021122010,100021111043012,102122101023020,110124041140000,100010044101002], + 1000020101003002: [110141201302122,100023001222000,101002124002220,102103012004030,114034000012210,101044004000132,114114004140010,101010241113102,114030142200400,114001124010240], + 140422200100410: [110140300430002,100021300412300,114031112210241,100002430012110,112000312000120,100000211021200,103013000110110,102420244023112,114322402322100,114400244140102], + 102013204020100: [103223014033210,110001311210334,111403414421302,100002001211230,220321332020001,114012002212100,114203110001031,100002220001240,110100014401214,110440112110241], + 100201101020304: [110210221300113,110304014433122,110200004243223,102000010200200,100002330412031,100033400410104,110210001310230,114020042302142,100010144303000,102142231143322], + 100100424100021: [102131104023111,102420130230104,103000004010400,100000004310002,101021014224121,100012114210011,111301000000031,111200304131014,103020200123211,100000340120221], + 131000114120111: [111200200000232,111410210001002,100101001011114,114220104000102,114000332302320,102100221341001,100011301000021,114310214033042,100100001040210,114102104121201], + 100100000020020: [103140211443110,100030001020201,100242141004122,101302401003202,100004004102002,112020201120340,100204220000112,103210200100000,100000001020344,100042330122240], + 1040034200120002: [101010304211002,124123100342003,122430211012021,102130104020040,101010004034210,122420404200443,144040423311121,121120220012120], + 1110201222030321: [100012400101400,111242212222022,100020100100300,101242000300000,102000014002101,114102404120000,102004021442313,100121211012110,102221220204211,102130044134200], + 1001112122000000: [110304044431200,114200134110042,104104112101440,102103131122203,102100101140030,112120012011020,114322000010200,114230144114000,100033044210014,112221114014010], + 142311002100014: [103324024030212,102102012003220,103030304021102,114110004121301,102030420223110,112002220220002,110000130020003,110303022022010,103120321442020,101444321101021], + 132401210141240: [101011100210312,110434314221324,110321011232112,100400040013423,110021112200120,110011312231302,100400410013040,110110302214004,112402344022203,103002140104010], + 112030010214044: [110011411102000,100022001022231,102314032000332,102300001100200,110420020000202,102023024010033,100001144201220,114240010000411,111212204101240,103210031410020], + 111203000012000: [112224111100141,111102214104403,100132004231230,100000030000001,110021340020022,101010001000320,110210020104031,101003204000300,100130334030100,112130334042201], + 300022201200100: [101012324214020,100000041041202,100000004214210,100120010020214,103411120100301,102110211441000,100402110020100,112000320221241,102100120311400,100103301022000], + 1402030133033134: [100010234114300,110010024201241,103032221421243,110200000403003,103210030110012,100112224000220,110440020030202], + 1013121002202202: [101302134233230,100000130010033,114102224000201,102312301104422,100022021041122,100013011020311,100120041020012,102012204000242,114000200042311,114300234001100], + 122203011312043: [102420101111121,101222041041012,100032124210042,103222000100010,100100000021020,131213314114102,110020000000320,114010024020443,111302002221301,120300012041400], + 1422200011020100: [102300324010203,102040011121100,114310000001232,111322234130000,110104002010100,100030024303023,102042204000300,100001134100120,110301232000100,110303401230040], + 1144343013304412: [101203102121344,114001024011334,112022411112104,102142002031221,102312144114200,101420211014000,100001214100201,120012102310332,100344224100402,102200204001120], + 1240200203011201: [100002000004200,103040000100120,102030324002210,112023102304030,102301030241010,100022001043023,114221004110220,100114100032200,100203104320000,101230321023001], + 131020140201201: [114021302304042,101032014010201,102120214000032,110040020021001,114222104103200,111000024400222,112140311100413,110042322001120,103013101222000,111001404112030], + 1102230011004120: [100020004313034,101400120320033,110430030000041,102020004000301,114114204001401,101042214000121,100014300000200,101031101024100,112000210242204,102201022000411], + 1022233204221200: [103311011404143,101011010320431,103041414001042,100021220010031,100000014211030,102441324022342,101041301000020,103220000104122,100220121003120,102040124010141], + 1002004102010310: [1010400230221020,103034010121101,111300400002313,111101040014040,100023014313010,114021040010311,114140004123122,100002301021040,111020002202333,100013040100000], + 1021412003303320: [102142221342202,103043404000202,102420000202033,100020101020404,100002411021201,102110010210330,100012020410400,102122111402420,100031404302400,101301014220002], + 130200041002100: [110120144200000,101200221022044,110241112020204,100002004104004,102100224000210,102310140240012,100014204201000,102103321411004,114113000004012,102140114004004], + 102420123010001: [100113444000011,101101400332443,121402220120031,114020224121142,122220022201102,101241421010222,110203022121202,100243210430220,101023114000013,103022300110404], + 1140000000120112: [102011201101012,102300304110030,114412000003141,114120430002002,103020041420212,100112011040011,114033300041020,101201220300012,100401024300321,100102030423010], + 1040220000302042: [103211200100400,102112231020231,100022004300020,102030304001101,114201204111002,112010122302144,100000114103021,101310000310240,100120244301401,100002230010314], + 1410110222222002: [110104112010103,111102004100101,102202414041044,102140014001101,102000104012232,102021100220101,114443330001442,100230120001003,114000040010421,112042110220004], + 111000440320142: [102242201000222,103000004011102,101410044020102,101000011032120,114004202210130,101220000302410,100004210412101,102102042002001,101210321023022,102110444130000], + 102020300100013: [111210044131101,102220000202044,114032002303014,101242421020211,100000004212021,103110314000100,100000001224221,112301111130031,111013102200342,111204200002001], + 322030211033030: [110201100100220,110033322001424,104100202101022,100041230102210,101131141042121,110012012004102,101320244221142,110340310102020,110102431303010,110424014243001], + 104320010330101: [100004204302330,102341014010003,100011421002120,114140320223200,101000030321400,114132202312102,102211401113441,101100220330020,101014324010000,100004400100414], + 100300332042200: [100041100103433,114104310000002,110211030011400,102100011413420,112404000202310,100400000020403,110233220002030,103020010100321,110140004200100,103402000120002], + 1000101000040003: [114202200000200,103000021411202,102101004030220,102003001132213,114120014000103,111432000004311], + 1100300422413040: [103242420100012,110002320424340,103130311444100,114102134122020,101040004010012,100100210000011,114004030023211,111343012200000,102201430201310,111100404100043], + 102203044000000: [402000401204030,114124020222032,100140201000222,110110000004210,101400010303002,104200202141001,130030220200012,112200110000221,1120023242400240,1321002023100013], + 1110004402104400: [101011220324041,101300000310200,114220110001121,100031004311400,110020011223233,110013000002041,102220004001014,100043000201333,102141302001013,100401302200302], + 114100000112102: [100121230031032,112000431120410,103042024040104,102304104110001,100104211044110,101342300314204,114241222321321,114021002302020,114013124030022,100013200100011], + 130122031422000: [100002100100210,102420424042020,100010001032223,114321002320001,103020031403100,102200401111200,102000430221040,114003104031111,100100000422320,100102020411200], + 132140100012020: [102142221342202,102420000202033,101012400343401,100020101020404,100002411021201,102110010210330,100012020410400,111111102240001,102122111402420,102001041100103], + 1140000033000122: [110140044401202,101300124221002,102112002004120,114400004141104,102142234000020,100314420140013,101401204040200,102030001103000,100040021031201,103030100142040], + 1040110200023114: [101020000323002,101424211100010,112112014020004,100221020410001,114314004030042,100111001020220,110321132002134,102203010232102,100411000433012,100210024221001], + 1001011344031040: [100440444301004,101221121020230,100232121210011,100004110000301,101310004223223,111210402244301,112022200234200,110043132100300,102100011341140,1120022020242320], + 1043001223203202: [100010400022200,102300001002144,102302444110110,103001000142003,110310004424232,100402012200112], + 1044142043330300: [110104112010103,111102004100101,100122004300410,102202414041044,102000104012232,102021100220101,114443330001442,100230120001003,112042110220004,112203221102231], + 103011000000020: [103140044032100,110322100104010,100031314241140,114100004121121,114110004002200,100040214102023,103033044023040,102403101400210,102301000241011,102100330231011], + 113010102200100: [102142221342202,102001200221011,102420000202033,100020101020404,101000004010012,103024000103302,102244221114031,100012020410400,111111102240001,102122111402420], + 1123220200040111: [102030410223003,102032022000041,101020220323012,114002420040210,100000104100124,103021104011000,110222122042312,100143110421000,102210100242220,101010200304240], + 1220102211104000: [100021104340400,100003000410404,100230404343341,102002301442023,102403001400101,112000134002211,100000001020020,101221022120042,101230210302110,112121001100010], + 104000400020313: [100111211021233,110100201140241,112001022300000,100203210003004,100042204102400,112120124020214,111304442220340,110003001024303,110032001122110,101000044001103], + 1004010231003430: [110001112031124,100200001003212,110001210004013,111012114400321,110012042001440,102114001122300], + 112320040110030: [100402130020211,114021200013041,102103034000310,102232014002212,102101030210403,143304200441210,102110111401120,100401024302230,110022001300202,101103000333012], + 241110022000010: [103220011411101,114220014111304,114032234033303,101030301000221,102302331003300,102003111413120,114200122340300,114201022330011,114020420030200,114143024003322], + 130410121210112: [112102202040000,103140211443110,102110021341014,114320100002004,110203221112042,102110001401222,112023000234400,100120004230204,104200401300100,114204004003310], + 1001010212024102: [100140201011204,104010100010424,103010014013304,102103030201001,101203104200224,100010221031023,100140000024021,101223024200014,112240404012020,102000220204011], + 1410001430021313: [112002140242302,100022140001044,102402000203231,102110411023111,100221101000314,102234024041024,110013100422233,110002241042041,101213412120001,100112014233000], + 1030000200312200: [402000401204030,114124020222032,100140201000222,110110000004210,101400010303002,104200202141001,130030220200012,112200110000221,1321002023100013,1103040030102440], + 240022400321101: [102141212000200,101203121020430,114144014122041,100022001040322,100000130010033,110020030024004,102112204131410,102324000240024,103020014040000,102312301104422], + 1012301004020402: [110130321300301,102240200242002,101000411030013,102110312004000,103012004020122,101322310313010,100000000410101,114403020000214,101014020310002,101040024002322], + 1022204000010001: [100002001013012,111220032224301,103400104001342,111001212200200,100000331201012,111210214440200], + 1102434402040110: [100010014200143,114020040031020,101111120013000,112022204004310,110320122100410,100103000002102,110400122022003,100242000430042,101014320300311,114223434000010], + 1441012331410144: [100000334212011,114204302320422,103130140210221,100020000102421,112000040243410,114000004102342,102020021412100,100010420001220,112120210202111,101000024000230], + 1410431040011110: [102401121113302,111201210000103,100101101010100,101320040302031,114010102300010,102321044112101,102000014002000,101034014011332,114011102210402,101203011023020], + 110022022004132: [103003114000120,114402004141433,100042401022030,102040420220132,100003244104241,100021044101011,103010104002213,100002221040232,114014434010210,102111001410032], + 1100010040010234: [110020014212242,100204104102120,101134220330310,114202414004000,103202444020203,114321310010234,111043200020202,102300131002024,102203414001022,112022110220022], + 100100031023010: [100221424320111,100021101021200,103240321400010,102010134012140,101204211020322,100011411040002,101002114000002,102414000203000,114010000020004,101220220040040], + 103030430212110: [101023124002002,102121211340110,112203044010404,100020020102201,102111400210040,102000134003010,102140140230002,110100024400410,100001111040010,100002121020203], + 1120120000224044: [110103101201203,101422244020101,102142120224022,100002021021020,102104100233030,101210010304011,110001000000020,100012210001220,111022004124100,111242322242000], + 1041030000000401: [101040014000130,103303404020012,102010200213332,100434121014201,100210001002120,101000004211110,101000021141201,114140024000003,102010014010000,110034420441200], + 200041200304021: [103100021440001,100120100032121,110000201324002,101200400331110,111201022200100,102100100210100,100002244341113,101000141033304,101011034001210,112400002300002], + 124033440132420: [110102401201204,103020200141000,102414034040100,100212030414010,100412200002013,101200020303202,102020041321410,111340300010010,114120420223002,102013224003020], + 210201221130031: [102123220230210,112301312020123,100111304300020,101110004021320,100002021033103,102201230200104,103013404041301,102022010244000,101021101001111,101012211020220], + 1030100404001000: [104232210210303,141111210002414,102000444004121,122013001001000,110002211101112,100400100013010,111300212011230,100401002201241,111022032202320,102100124003112], + 110220333400030: [100032041021210,111202012222402,102001301120112,102040041320010,103203401400132,103142111441040,114142044120310,110220410000040,101030004010034,102201411100212], + 1002102020000000: [102434010203000,112100134020004,102001014000312,100421300020002,100003320120242,100100031200121,103232220100413,113400320100001,110204201314400,111021024111304], + 1000102011012413: [100013230100000,1320100232411004,100121120102303,412310220104121,114100222340120,132011000122003,110230010002303,103002020001300,423203002400042,1302321010020120], + 1102100214231432: [110021000410432,101010010320112,100021111043012,110124041140000,103300021402104,100010044101002,100001000100403,100020124100010,100301020140000,102102024000001], + 1100004324203103: [101040040300223,114234004000210,103000200112220,100100001040410], + 202324002000110: [103030324000302,101340000342212,102002304010024,102040120220003,102120211022402,112220132033122,101201004010204,102310100201021,1234032021030300,100011000420231], + 1022300000020022: [102033021130021,102001241410312,100000121042240,102101201403410,114444012310100,102330021000131,110400240002411,114432422322332,102000320222120,100422101002110], + 1100340020222310: [110202004211120,110223224433004,110341010044330,102031144010424,111212114131222,102140001441301,102342120222031,102221010201113,111012030022123,110031424214112], + 110130322010021: [101133114022040,110210004434230,111100132241003,110100000020000,101134414020201,114101042202201,111424224422011,102301340200323,101000004210142,101340020341021], + 122243013240222: [100002100100210,102420424042020,102000430221040,100100000422320,100102020411200,102100012002000,114221030000011,103002110100200,101320224220103,101302131002410], + 1431432211000132: [110100104404110,102110042001043,110200200400310,114100002204212,102003000212104,110000011301000,102000100220240,110013001200012,102030204000041,102341101101130], + 110320020010144: [103000144000400,100110011002040,100140011002400,124001030020034,103214000212400,134312110020403,103130121241210,124002000123111,100041011030000,102010121122221], + 1101110204000023: [102012214041011,102010214000220,110411344210012,100100014322200,101042134014101,111141022224102,103004030120101,112221404014110,101032011143223,100304431004012], + 1020003000000432: [102212124010301,101001000224100,101100440120042,103312141403200,103032411100001,114020100040024,100020114210041,101411004021001,114213114003203,103214331421023], + 1442032302202000: [102201041003000,100011100124001,102002321030001,102031101030023,111422210000120,110401221311002,103003041414310,110111100010001,111002100001220], + 1022000101013020: [102030410223003,101020220323012,100000104100124,103021104011000,110222122042312,102210100242220,101010200304240,110102010022243,110020201012400,100140221000000], + 220011110021310: [100042111220111,112220100202000,100042041220010,100403211010100,103240301400123,114102210214041,100021300103041,101010204000242,111334004121414,114101000213410], + 1004123040223110: [102214100240020,100000001233441,102120044000240,112100012011413], + 1401303100022304: [114003212210013,103023101400002,110010120440200,100002100100320,110100034200300,100401201010220,103200024021204,102100204000234,102043221012112,1000023402103012], + 302002023003010: [102044104002014,110200004243223,100033400410104,110210001310230,100010144303000,100102434300310,102142231143322,100421200001003,114024200040223,112020402001012], + 110004403014034: [110001332120300,110003000420200,110243234240200,110004014411012,112000120232022,102041220200010,100002320113100,112240200202201,110020321120011,102130000312121], + 100000420112001: [102340200224222,103212000212121,100100011010220,112002010220004,103211014000111,102000034013222,102030021100041,103210214042004,102311020240120,102402200204112], + 1000041420014213: [104100002100221,102000321102310,102134044134410,101202001022000,111300220000230,100133204300040,114110032343001,100110101040020,114012222301110,103120440104110], + 1002303101202401: [101400004022100,114031212300211,102013110201200,114023010024000,102042321440100,102300121004222,103002020142122,101401101012402,112000230220102,100000410122022], + 223140110321312: [102304030220001,102141124004222,102430201110000,114010200020312,102124002000102,112042422001032,100011004312001,100111200414020,114044414023030,114244014002020], + 1022410320300101: [100104001041200,102012200202303,103222114034232,114122112202230,103221204032410,100010141222040,100004004102410,102104320200023,101104001101000,100020001030022], + 1402232200001330: [114410024110002,102030410223003,102032022000041,100020000120134,114002420040210,111201122241213,102342022000024,114000222330121,100000104100124,103021104011000], + 1000022002004201: [112000204001011,114004100011010,102030030202212,100022024100312,112003120214121,111300100011041,100030201041011,101001010310002,100001000400001,110031400432422], + 1102213010202023: [101302134233230,101030404212000,100431000032001,100020001042002,100013011020311,102103331400000,100120041020012,102012204000242,114143024003322,114021444010222], + 1140010030202200: [102301002004242,102013130223020,100131011001300,104100302102030,103200030110000,110102202013213,101003014210212,110000242104040,100210024300001,114000444100400], + 132030111000412: [110401140004202,110040002034100,110044020020202,110301311303102,110201434430102,101002020342002,102110334020204,103200001420012,101201021021111,103210000112442], + 1201233400000434: [114012020044224,103030411422014,111112204404021,110404122110112,102412044040011,110411004223302,100100241000020,113130020101411,110021002124000,112200030203124], + 1032010214322202: [102431111110001,102323101101400,1003002030122040,101230330042220,1320124301012211], + 1010022303400004: [103010010104000,101100400333023,100141004030100,104130442103041,112314322001102,110000144202030,101210121014010,110202201303021,103031010100133], + 121021240030310: [114130012310000,102112432004423,100210201001001,100243120430140,103241131401223,112214431102032,100400120013011,102202141120400,102211241120212,103011001244001], + 1002401010324142: [100113444000011,102100030230010,110020411000411,100000221040201,100100010101102,110010110023200,111020000010212,120031401224002,110024404203100,120000043000003], + 1404000200300230: [110230231300100,102010424000101,100300121000420,100402431014100,100100001220400,101423100300002,103111300102020,112202012030100,110300011202224,100043300401302], + 1410003310410302: [102101211411000,112032040234431,110010232004000,101020004000000,100102224033421,100120040400011,100400110020244,110410002020200,102021001411110,114222010213042], + 1000022201011014: [100000200202012,114404010003320,112114324040000,100141011011032,100010021034000,103132004002020,100000241000002,100000401002031,102001204001021,114300104032040], + 1001242040230020: [110011232100412,100220040142222,110020120040121,110000100022040,110200021210212,102401010202301,101040000301210,114240000001020,102130034023112,102204114114214], + 130030101100110: [112133212011000,100041100103433,110211030011400,100000431230142,112404000202310,110041122001022,110233220002030,103402000120002,100112421221110,111020102204112], + 210100402301011: [142020040041320,102124021023300,112444304040204,122022100000222,114200004110244,100003024211200,102102402003021,101210101010023,114422114140221,103210000103000], + 110003033212032: [114020000030002,100201211003004,102014002000401,103103241421322,114121012340044,102000400240203,102104304023201,103310300140324,100002224244002,114310200002400], + 1221010320140300: [114200034110031,114423002314000,114040002210432,100010040122204,103314044033003,114102224104002,102001420220112,114422404110312,102403144000120,101033041032041], + 220241142300040: [114231404034301,101040231124131,111103304400110,100004011120201,103024020000203,100001011120001,104002232100303,100041020143410], + 1031330320413214: [101010211001011,111220030010210,114042034104243,100004030411141,100412030034000,114000214012010,100030040000303,114010002240111,100012234200200,110302120012014], + 120214202240112: [101042014003022,102210020240030,121401221221000,1300001101120141,110020000010044,110111044402003,112032041113001,1112010004112414,111043124112002,1200023010410200], + 1140012420221010: [100002100100210,102420424042020,100010001032223,114321002320001,103020031403100,102200401111200,102000430221040,114003104031111,100100000422320,100102020411200], + 1001000210222421: [102100441341013,114201102342110,114101200210030,112011200240420,102040020220000,100104004100400,102002331440012,112100002302240,103312401404300,100004030101401], + 1000100111033300: [112312122020210,110332000010101,110022331320122,110000030132210,114002004103231,100001004311313,101403030300132,102321021102143,103123204002120,101010011001214], + 100023020020210: [110301222101110,100002024200142,110033041200104,100304011002220,100003200120102,101100031042003,104120110010402,114240032321200,101021120344004,101024420304241], + 1002234040020300: [100200101000000,103110431441100,102100441341013,100011200121231,111201102224324,114040020021023,111230114102201,114201102342110,101400300300111,114430204112100], + 140000100011001: [102011214000000,102110111410144,103023141400000,101001100300012,101041104222000,101203414013200,103002201220000,112000202310100,101030010322420,110001102102020], + 1042210130010011: [102021001132040,102301004110004,110402420402001,110000112100402,110021021210300,110404000000012,102000101120123,110221022101104,110023100402320,100020311220412], + 314111100411012: [102241041000242,110012232002103,112021324020001,111310120000011,102000024011022,110201111314000,111140222113002,103213224041010,110104040120242,114200114030134], + 100410421200200: [100004001021111,101021004214202,100003000104203,102114320203000,101011001103200,114001112300001,101003104212220,102311110240101,114002002300302,100000304301120], + 130104121003132: [104404322124241,102032031130301,114030234020304,102200124012000,114002120023020,114421000001111,121400013334402,114413200000230,100103201040210,144000213202010], + 1010000221004003: [100442110030410,103040040000102,100000230401412,110213044200100,110134044242442,112210121100012,110221114214442,103011201241100,112102110203010,100220001210313], + 142143240040301: [110300100100200,101000224003200,102110140224010,102020011103400,102021324003010,110222000000130,103010000100030,110220441210241,110120021324222,102002012010000], + 302433002432021: [102214011111041,100002401040201,102113101342000,100212304243333,102300220241031,102302424110100,110000014211000,100121210402002,102312200240012,102212004030221], + 111133120321403: [110041202001012,100002121031241,113202020210311,102102304002200], + 1101003301300210: [100032421042201,100404412200031,100000001221100,103040224001431,110240242120033,100220201003103,100102020403042,110002202124024,102110014003412,100004101034200], + 1102304042120420: [102220011110041,100010204102110,111303034134331,102010200221212,114023240040131,112020021110420,103000000120110,114310024002102,101122440332111,102122100210030], + 213104002302241: [112142301101040,101000130320340,101121100332142,112401314040311,100110020031042,102011004013000,110422102110221,111200122222334,100220124221000,102301024113440], + 1102300211200213: [102140020210421,102112401342040,100010031232011,110010002200040,100222101000100,101002111141200,101412010300340,102422224043400,114304104033020,102102020311224], + 222124020411042: [114212104110100,102242201000222,100000104100102,102001040222000,111103214104101,102102042002001,112400420204232,101210321023022,102110444130000,110044222001040], + 1010340300041333: [102312441104020,100013411224200,110012442200211,110003302000022,112100222300311,102231011100310,101142320332414,110114004221012], + 200031023020211: [100002014200331,111020032203301,101000210303342,101440400302320,101012220323021,103000121424330,102111021022024,100300114310112,111100020020010,100202004324322], + 1102202024020044: [102040431121110,101221020040220,114111100021420,102212000200124,100300310140241,100103104302044,102141212000200,101203121020430,100030010102102,110041004200044], + 1000221300013104: [102000020223013,114040102301100,100020241043022,114413232320000,100100001040134,114441124140100,100002004130101,100301024310020,100130010101430,100020001030232], + 310340012100320: [102000100202041,101021041001434,111200024131220,111203034440323,110320222000043,100112401020300,100100000400120,101001031031221,111200004424200,112000211131111], + 133041110030432: [101440201100000,100003121040104,110013024201420,100112104300311,100002100021324,110233022230043,114000012210120,100030001042004,103002421401003,112101100420213], + 112124222120002: [101112404231342,110011401011100,103021030102410,110430314220010,102423100202400,114100212211004,100020011230424,102000034004310,102241021112220,114002114102222], + 113000121011001: [110240001202102,103200004030010,101002100340212,114200012321223,112000030210340,102100020214203,102201000203202,102302001000120,102111320321320,102010002000404], + 200401012020122: [103233020100000,100120414231002,102011201320040,110400230404040,102000124010244,102202431120401,100303204101034,100000014310210,100022201044014,102212204021114], + 1004310040031010: [101000024002230,101100020330020,101422021012014,111030222201023,111001200003214,102320010243201,103220000100301,101302204221000,110012020021204,101001420312100], + 1000000122040203: [100013204331410,104123000021013,101024000321043,101000001031042,110000030020101,101410101102110,111300400001004,101000040321140,110000321211330,112203044010404], + 1000000002310000: [101010201030113,102401004043011,114012012300010,102223134010120,103020440120000,102232004040004,100241224311010,103000200122014,111302120011012,102013220201100], + 1040220010100400: [102101211411000,100102224033421,100120040400011,100400110020244,100124021201021,114011120010030,102310100243242,101240404044020,100200044121414,100411201002420], + 1421413320421301: [101011400320030,114000004022410,102410012002102,101000134010220,112222032033421,112330302020202,112003042310200,102220001120020,100040000003122,112024140222012], + 240422402100404: [101020024212042,100041204212120,100410110420202,112423424042102,100320431000002,411200101402221,100120214230002,103204200103440,100210004104001,101410201111300], + 1002201010032044: [102100104000040,112132434020310,100000144104100,114200024110134,103340114022112,101014014000004,114001000010010,102110021341000,112440220203204,100100104102141], + 224003110224044: [101210010304011,112300212023031,114144004124200,102000121122000,110011424414202,110000214202000,100040011023003,100123031023104,114223212320410,100302114311412], + 110233020243242: [110214202044002,100041311024000,111003002230111,111202220001030,112100024020200,120120044004103,103040221410110,111001120001220,111120140012242,110130432212100], + 211201004430001: [100212424322433,110202212230010,103020201401020,102000401132401,114022020042232,110400204221003,101100111144300,101112041101020,102142101343402,101200001010111], + 1422032101002320: [111113202211020,101013004000130,112004030241132,111203034440323,100232004221200,110344041332022,100201000011432,101042144010200,100011031001031,101000214213100], + 1204224112141011: [110120144200000,114022412330004,102343230224321,101200221022044,110241112020204,100002004104004,102100224000210,114201104111034,102310140240012,100014204201000], + 1011100020240001: [110001100140240,102230114040102,100244204311004,112001002030133,100240203220201,110200114241402,112020201122220,102000100240000,100010201023140,114000020043211], + 1012241001010021: [114211010000210,100003040101420,101440004020212,110100201000100,100001024102310,100000004210012,110202102231202,102112000204313,111111024404430,100224120001302], + 1000222343220004: [100022021024200,102002301410122,102142020212310,114100220004120,103010420140201,100022401001413,100101104303303,103304004023413,100022201043312,102002410201020], + 1022200022201030: [102233404040001,111220244103011,114103204100320,100020021022433,102000044000420,114400000004004,114202002320114,101003401032000,101020011031332,100032114210020], + 1003140120011010: [101221020040220,100103104302044,102020004000014,100000211023014,100201111002224,114242410001010,114202044111100,102013420220240,114212100211223,102102044001132], + 1022040020020303: [100042100102211,100300041001121,102110030200120,101240004011021,100120014100010,102303030241010,114001112300001,102202144110114,101013220320021,103002020142122], + 121030201021201: [112113214020100,102010202004402,111130312211003,101001010300404,103340004020422,102420221112201,101224044041002,102211430202033,100010344310042,101031321022412], + 240103001022000: [100233220003022,100040104202411,100040204313012,102101002002010,102200000201240,103200001423140,110431012224002,102123402001200,120103342024110,114220320210120], + 242322430033202: [100020214301001,102022024000100,100040001230110,103010100143010,101022030320100,114111220030210,102030004000400,100021020201421,112402122023323,103034201424002], + 1000010302120013: [100002221021122,102122111412001,100031430104201,102030100200300,100000020002303,110004031201142,110032230410440,100200014301133,101440220333000,111303102204110], + 1111200020001300: [110212012114431,100001140020000,100012101223021,110013030020121,100121104300201,101220330300003,110132000024420,100011014130012,103103144000200,101003131002404], + 120213302000302: [110130102010010,110100030123401,101000011000041,110001010030000,104100302102030,110102202013213,110000242104040,100003110022310,102220314013103,100022000200002], + 111321043004100: [100032041021210,110001041213031,102300324010203,110414300030001,100030020011022,102040011121100,111202012222402,111322234130000,102040041320010,102402104022000], + 1021000300402040: [100303101202010,100201244032040,112012000212410,112000102000300,110104101002000,102000034013010,112010102001040,110030202101140,103012100122324,111202030012240], + 101024012430110: [110102224201130,103301201402204,102401121113302,100021020124002,102104131412412,114020312300021,101320040302031,102400204043012,114010102300010,114042014014024], + 102211043020114: [102120031140142,101010224000130,101000414002041,102322004112023,100222044100141,100020140002030,102134144003010,102010420220104,103022301400010,111240240000201], + 130010310333012: [102320130240202,110140042002031,111001024132202,110223102022103,110010132030102,110120100000300,111013244111024], + 1130301021023100: [102021400220100,102301040242220,101020041110102,101401414024002,112002002021204,102140111141440,102202102021204,102200121300410,100400002201023,112200322042040], + 1000012043200222: [100341320422234,110110132041402,110020422002214,112034310220200,111022124400200,103140240112020,101404114023200,101040214002020,113200210100211], + 110123031100101: [102121221343020,101400010303002,112104424022201,100013211002142,130030220200012,112200110000221,1300034431310021,144020001004041,1001010233020100,102210104000000], + 101323202030112: [102100022003140,102102211021113,111400024404023,110020122000043,101004001030002,100210120430000,100010004100021,111240124130104,110012211001003,111103242111211], + 121001310402023: [101010010320112,100021111043012,110124041140000,103300021402104,100001000100403,100020124100010,100301020140000,102102024000001,114003104032034,103214430100103], + 110001411212010: [100020220420321,100120004300002,101000310140030,110302010102310], + 243100400000122: [114000042302220,102000021101201,102141300232324,101024401112120,110140141201202,102341100242122,100400002201120,200030234030020,112020311120102,110000000000000], + 1000322000000011: [111101220012213,102330230243214,102202020204012,112104230232110,103343430113420,103023421431022,100043404304122,101230134011232,114013134031222,102204001121032], + 1000402100302214: [110100104404110,102110042001043,110200200400310,114100002204212,102003000212104,110000011301000,102000100220240,110013001200012,102030204000041,102110021341014], + 1010020123402103: [102403001342000,100400020033040,100102431021300,110200212041001,110021224200431,111210224410302,104110100014103,112310402020014,100033211230014,100001211040232], + 103104002232210: [101214104041040,110104231221040,102012204010044,103101000100022,100020141044111,114200000002420,101024420304241,110401440001204,110204310112224,100042110122000], + 1000143101402202: [101012131000024,102120221022200,102110141410402,101044001032114,114221104114000,100001111032112,100400212200322,112400004020421,103221021412001], + 111020203013314: [100400220013224,110402021310312,112201000410000,110401101112014,110014400040200,101033234000033,111414014420011,100102224030230,114323000003430,100000111020230], + 142224011000001: [114004102300332,102020010200114,114103244123211,102240044042003,102331010240100,102003231440340,100341231202001,100100020021020,114023102300012,101000000321010], + 143141122114011: [110231202040203,103014224004000,110024404201041,101040001230002,111200010014132], + 111004103010112: [100030220422042,103442424001120,103101001210223,102210324032234,102220001100011,102202421300101,101013001024140,112000234001001,101040030320010,102100041140211], + 332402034330404: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 1421124420041003: [110300120403013,110131002010202,110140044401202,101120101100112,102000300200231,100002030410210,102231031123103,100221321000021,102010320232020,101043314210310], + 110202413200020: [103242420100012,110224044242243,101400004022112,101040004010012,100100210000011,102200000200201,110020402004210,103110020210000,114004030023211,102201430201310], + 1040121123202000: [100200104321000,110000110410110,101021000341001,112032302000220,102004301444000,111133030010200,102103231340304,114000044101422,102020204002424,100003044240120], + 101001202100021: [111014202144002,103222100100201,102101034000000,114004000044132,100131401022011,101000000312200,110022124200220,100010321020020,100122430422300,110011002100202], + 221334220100442: [110010022130210,102000124012341,102321101000300,102010020210100,100000404210104,103100104000130,102104211400330,101130024000302,100210310002000,111303024130204], + 1041002103101211: [103004420100020,102220032001000], + 222000111000200: [111333104124202,101004120224442,103102000121300,114000320043340,111100030030120,100320421001431,100024004304130,101233021020010,111100400022041,110320002020403], + 100043121004014: [102020200223310,103043404000202,101001400301113,100002120200101,102014111102023,102432114041004,101301014220002,112410300200001,100021201020001,100112240020023], + 112101400003100: [114020014110120,102142030224211,101000034000220,114102140221100,110000121300012,102112411342231,101033100302011,111122004100320,110034004420011,100202140430130], + 1000023022010021: [110200411140130,102301002004242,100131011001300,104100302102030,103200030110000,110102202013213,110021404214210,101003014210212,100210024300001,100000200003102], + 1003202110244000: [110020001310000,110214024430312,100011014100041,100310201003000,110412121110214,100212341003212,110142300120000,112013212032000,112010220224003,112001040231401], + 1100012401200032: [101222321200012,103103240104001,102123040212103,100204104322122,100041301021020,100102001301220,100020011020010,114130000220023,102314224010213,112113012010000], + 201141100111002: [111121100010021,110310034424102,102101211410144,100024201030210,102010111102410,101000110322242,110100001014311,102404110230202,110043400012000,100010020101222], + 220204431033020: [100243401002310,100004000100101,114230014000002,114130104001000,101004000304012,100022210410130,114034424104042,112043001120130,114021214100300,112204111102324], + 1111021122201211: [112003001123403,100200004300314,101101424003234,110034022104420,102101210314100,112013001120433,102240001121213,102200000240110,112221030222111,101010404210042], + 1011010232142210: [100200011002200,100211041001012,114002102301240,112001112002104,112200000201104,100234124120220,110030010120002,111003212230033,103400130120100,111020404402004], + 100140423230102: [110012140020202,100003421041001,102010212000134,100000300100343,102110021341422,114241022332104,101403020334021,102002000224104,101200201010041,101212430302203], + 1032301032221042: [102000004002101,110202000000310,110000010120043,100422314300200,101403014020203,102141410230020,100042030120422,101134224001001,110020001224021,112100000200031], + 240000400333000: [100002100100210,103020031403100,102200401111200,102000430221040,114003104031111,114000044020204,100102020411200,114221030000011,114200302341234,103002110100200], + 1012001220400002: [114034030020130,100000301031020,102422310203100,114224200210241,101010244002013,102343001000312,100001200102200,1001233110104110,102100201341123,101101030330100], + 1433033010002414: [102110000203003,114002010040032,100400012201120,101204014010434,102020022000021,102000114010020,102102000312101,111043144410240,100020101030012,111222032223120], + 101142112000021: [103122020213112,100104010021241,114101100211240,103012011434022,101032010342004,114102102344110,114010002300003,100112110020301,100000004102124,100022301000112], + 1101131010041040: [112000431120410,101342300314204,114104200220022,100021221021201,110001244204302,102010244010000,103003204011330,114200034110031,114423002314000,114010134021022], + 100401020211000: [110020301320101,114013212300032,100014030122001,114001034010131,100340204310400,110302220011010,110401041140300,112143002312100,103000121403344,103310041402103], + 102104410120034: [100000021040000,103120304002002,101000011111001,111231434104200,110222400112201,104100021240122,100033300410212,102110042004000,102201000200211,101100321120001], + 1001310000104421: [100004001021111,101021004214202,103022021431010,100003000104203,102101220214011,102114320203000,114001112300001,101003104212220,102120231343021,102311110240101], + 221000313224300: [100030324200410,101000001111200,102300404024300,102113200210140,100040041020102,114200020003431,114041002212302,101002200343110,100212024322044,100140004102001], + 201000010033001: [101204334232020,112012002303014,100004340004131,100210421004302,100200411000410,102003101130231,102240200214023,111021220021002,102101024002102,101023011142204], + 1001220422432203: [102000034011002,103204000110000,100001014340021,114203202330210,102103001340022,112032000211000,100002110000131,114100102202223,102331221102213,110021204411214], + 101003121003132: [110332424431130,110011414201101,114400104140001,111120442100320,114312112320302,110000121033240,110122114404243,103100024003112,111010242140140,101112121144002], + 1020204211302421: [111400124420002,101033124000402,102401000201121,111013232200403,100112044024030,102214104010210,101202024231020,102201100240444,100012001020330,101013411000000], + 140111020022000: [100440031001120,102203004042010,114203042330220,100020001041410,102032012000101,102102231400111,114014112302234,101004201001232,112102102302000,102141231343401], + 1031202210413240: [114003014100103,102010420200220,102033001100221,100210144220030,100001410012241,101003004000010,110000042000440,112001132340013,111002130041004,111122402242000], + 1010021211301100: [114020000030002,114031000022030,100201211003004,102014002000401,103103241421322,114121012340044,102000400240203,102104304023201,103310300140324,100002224244002], + 130230002001121: [101233110040000,100001214100401,102422221110121,110123104200100,100200220110004,110422120034403,103102200210402,114001102211300,110400031000210,100010134202001], + 102441000440213: [100442024301200,411231400122100,100400414321103,101024000322432,110302030412400,100110020000040,102132204131302,100010100000320,110020034203040,102014031440442], + 103224100021030: [114003212210013,110302012103114,103023101400002,110010120440200,110024140022040,110100034200300,100401201010220,102100204000234,100211120140002,102043221012112], + 102330411203011: [102340421000001,102040410243001,101031122400122,114342304031011,111430442210202,102143341004201,100202210000020,102101101400002,103304110111122,102103114022230], + 222312020302324: [100120201020014,112433322023300,103202404032404,103331140112102,103121211441140,102230201124100,112102330202300,100400202200330,101403200300001,102011224000020], + 202003000303201: [100000004100202,101024004002101,110120041200201], + 1022340400110004: [114024312202242,100020001011422,101023321000020,100110411200024,114020000022214,111240020000201,101012230312200,100442041001211,102004131410330,111120024404002], + 1034112100120120: [110003000042343,103001224014142,102304000241010,110011000043131,100004220412332,114102400001020,110220201301140,100022221044012,110312300010200,103214210103210], + 103123020001212: [111120230020122,114301000000002,112124310203104,100113324103000,102001000221124,114040204014042,100040401020413,112414334044310,114001010044120,101010111033143], + 1222000304210221: [102231130213210,102000402041014,100043324210140,114113104123200,100023024211011,101210210300031,100003201021001,110002021121023,102300040221403,102201100200430], + 110040202310000: [100004001021111,100003021033300,101021004214202,102110020202330,100001010014420,100003000104203,102101220214011,102114320203000,114001214100103,114001112300001], + 1002430204000011: [100002414210010,100021014100124,101020104000001,103013200120113,101313004232122,100142221042020,102012200200030,103210011421102,114202124000200,112041432030144], + 130133022034003: [100030420000100,100400030013203,111200314440011,100421320030200,103210400102031,114240042320132,110410330000000,114100042343200,101223240301022,100200044121001], + 130221220211110: [110232022123020,100002004303100,103140044032100,100010240101221,102100010213413,101024011034002,102000041101100,100032224101400,100042004301301,100012021031014], + 1041003423011011: [100042320001030,110024001010110,100100014300230,100001004300242,111120044100110,114240314000100,101002411030000,102002324011002,102400001113002,102413001402023], + 140220200202201: [1010400230221020,111300400002313,111101040014040,100023014313010,114021040010311,114140004123122,100002301021040,111020002202333,100013040100000,102011314000200], + 1101310120000003: [103102041440324,112110032304211,112200431102021,111320124130040,110042234410000,102424111401024,102030200222404,110010042000123,114040340020333,101100240320232], + 220012401200004: [111000222232122,100102204231301,114021140020102,112201104011200,110003101312402,102014002000001,110341024422102,110024120430323,111012400013240,100003240003001], + 100410000204202: [100121230031032,112000431120410,103042024040104,102304104110001,100104211044110,101342300314204,114241222321321,114013124030022,100013200100011,114104200220022], + 124112142003300: [111304340002030,110102000401214,100100111044040,102024102020000,102224241110003,100023101001004,102001014013004,114022100010000,114321004030021,103210210100210], + 100222000201141: [111220202240410,110114002004014,100010114200031,101224110303300,110003020001402,110100200402003,114001000010302,101020031112040,100020134200102,100211114340130], + 1112112104001010: [100030324200410,114202244112111,102110202001010,114420200000104,114041002212302,100043200102020,103332044032320,103102210210321,102420030231021,114040002300000], + 1001024020110042: [100321004011041,110002342100014,100301300121100,111101042244210,110124002040002,110023410122402,110042400130000,111200020004203,104101201240100,110000011012202], + 222000000111030: [104110021244203,100200004301323,110010030440201,110041002130210,110020004414024,102103022002001,102102224000012,102100102001032,100142431013000,101000031001011], + 301201321412114: [110241024242442,110444010032242,100001041031013,110300112023012,110224200113042,101000020301410,114000102210200,101041001032310,103103210111220,103100100100104], + 1001401204010041: [102001200221011,114201004110120,100412114304000,102021014012210,101000004010012,102244221114031,103030104000102,112400000200011,114201024112001,111101400011011], + 122000221134002: [100032041021210,110001041213031,101110044200100,102411000200000,110414300030001,100030020011022,114100122342002,111202012222402,102000221442214,102040041320010], + 1140040230300420: [112213000200301,100003224334120,100404224300012,110204130004030,110003200132101,110202120003032,100322004314021,102022010220223,100404000020012,102343301100440], + 1020124302410002: [100031120101224,114122220031004,112040200233002,114022214031210,103234100101221,100010111040104,103103311424020,1132202011200221,101030010320024,102303020211000], + 300131400102132: [102033124002102,112410202021300,110000201301004,110002040021102,100000001032140,100110221000310,100030401031400,110031001010032,112220100201030,110002212132131], + 1031013004111344: [110111001300044,111000002202324,111211010001300,103210001422303,100101141042243,100101100022012,102020440242023,114201004004000,100220010002421,111210240010100], + 321212313310000: [102110000210300,131402001003121,104220041321240,114420000001024,103300031403210,100022131043110,103422421110341,102040300202332,102100100230142,110030140000021], + 1031114101021312: [111220204101421,110042120021013,112200420200200,101001010300011,114012020044224,102122401340101,110021020001220,112001024000200,110112030401012,111112204404021], + 1000100321030402: [102000200220320,102021030221122,101322410300004,102241210201000,114040222301101,102140110210424,114101004100000,101010221002100,100311121002020,101303104220020], + 100032110021202: [111101232220021,112100200202204,101022201033321,102001031103412,110033000020122,100230001202112,103100301242013,102004002040221,112001010223002,100200100000040], + 211431213023002: [100103301002044,110020102102000,111130202220102,100404200013100,100040104331012,101114024200021,102240041122001,110310112002442,100200320000121,101144411020100], + 1420000231002131: [103332104032020,112431212020030], + 1001400221103411: [100041000010302,112004202302034,100010044300003,111321314133000,101131024020440,103014004012401,101000134220400,102000401100000,114030202300100,112024021130010], + 1002203313010142: [102142221342202,102001200221011,103043404000202,102420000202033,100020101020404,100002411021201,101000004010012,102110010210330,103024000103302,100012020410400], + 1110400202040013: [110014002132100,101042104010000,104122202100000,110410000002004,111424002101030,100414231011020,103100304000131,100312021000201,114121110030203,100001122210110], + 1403112231441022: [102302211100230,110211100000033,102002104004011,102102104002322,101020110321041,102014401132322,114030304031042,103130321244400,101400221012300,102031001100042], + 1110114001102022: [114132202312102,100021110200330,110322110010000,103302034020140,103214104034020,100400000013010,110222201200000,110302400012002,100103004000123,101230234011000], + 112014020230002: [100130434232013,100000100421200,112201200202200,114331000001140,110310130104000,100220020432312,101403314001202,110002001300010,102040200212002,101312001001330], + 1002402303020200: [100200004301323,110010030440201,110041002130210,110020004414024,100031220121003,101100001102230,100031314241140,114302102300200,111042012220110,101222121020001], + 1034011130110130: [111410202221302,110002302101012,100111401011110,102000034004310,100114110411042,100004004104022,100223010432101,100002004340344,100030314201020,100100044032000], + 122140210310004: [110020301220324,102020100243032,100031001020040,100104001041200,102012200202303,103222114034232,101110404021211,103110041442122,114210400000112,114042014102321], + 1141420000042402: [100131424302300,102104004021010,112033000244420,104132001240113,114302044003120,100001104310020,110014210424201,100202234032222,114400220000013,101422404040210], + 332113304304234: [101400004022112,103110020210000,100022141030334,103200211410311,102100404021014,102303001102431,111441004421100,102000200223003,112030222004121,100141334301022], + 1202100101401313: [100210014322020,114010224101022,100230410112111,100030131042200,101203004042010,114221000210214,102343022000042,1144030041011004,103400004000422,210202104001103], + 112010020010301: [102022004012201,111130210020000,100000024210130,102034221103124,100014030200221,100020134212021,112001120220130,102102230203330,114100224120003,101001104003130], + 1002004221333411: [114343002322014,100022314100104,102130314131401,110200002031302,100013024312024,102002020243020,114002002300201,102040021121030,100311314310000,101002134210440], + 241120022010303: [100021311233000,110020200420132,103111104030033,104100031240003,102023021100022,102300024110101,111010204111010,111200302222011,100113144300434,100010010004402], + 1020402011024131: [111002012204241,110004202003210,111021400040242,100000221030033,110201304240304,100034404303122,101012400340400,100020330410000,114001030042240,101203004042401], + 1021134110410030: [102040431121110,101221020040220,114111100021420,112024212301420,102212000200124,100300310140241,100240134323001,100103104302044,102141212000200,102042000222002], + 1002040143040001: [111423000022420,140102120200000,110400444243022,110131001002021,203201100012000,122001000320022,121104330112000], + 102224413020102: [114201204111222,100104001041200,103300004021200,102122214131011,100023031000024,114210400000112,103230134011412,100012004101221,114122112202230,102021021101204], + 100003004002122: [100102134031030,110233000100021,103011041410132,100112104301200,100021242211014,110211104432213,101110040002210,101001210201440,111401304441341], + 132200004340203: [100041200010000,111114212112100,111000002202324,104132100011024,111211010001300,100113434301241,114030020020301,111014014401303,103210001422303,100100000022131], + 1133221102100310: [102141040210012,1101341442120200,103110004004103,114110012310040,422202004012314,111000000001024,110101112142230,1022020301440012,400020112402100,114300410001304], + 122401000020030: [102000024011300,101011210300000,101002221140440,102040021424212,112400020200104,100100001010020,101000000322000,100102021220030,112002022034002,110200140401144], + 1431100000100123: [100010424101430,114000224101044,102110022001111,101020301114001,102102300210103,103024011431131,101011324001431,102320200224120,100030014210012,114100300000120], + 1100000310014203: [100201114323042,102102011341002,102141024001000,114222144114122,103001000102220,102021010243000,121100311033233,111110202240200,100002000412000,110103400121140], + 1100100104010032: [112241020202432,103341411403412,114100130002210,100100001013001,112401002022010,103000214012340,100004204101200,102400134001010,102001004014032,101321040311120], + 242110023420010: [110010302000004,100014014203233,111422100034314,100102001013034,100001014100021,102030414003000,101342020314000,102112104004041,101020041110132,102422101111002], + 130000201201002: [114104032211214,102410400233132,114200004110121,114012004033222,101000321001401,110102210400043,110004004200130,102200200240031,102101114021130,112122000202103], + 1100400310031200: [114000222211300,102130040230200,114030034013200,102303214031001,100001010101032,102212241110430,101124314020402,114432002322240,110130402140002,101402104020302], + 1003200131132322: [102133404134022,1302221400222330,130000220021033,131114110030130,113000343131000,410120000124111,413200300004130,114223013001001,101310000020110,100103222310200], + 102110032002304: [102301344113012,114010200020312,112144220201011,100002131020410,101001020322010,114112244122013,100111200414020,102443421400110,114044414023030,101030001030220], + 1022141210111220: [100121230031032,103300344012201,100122200012014,103042024040104,114021002302020,102313204114304,100013200100011,112100102300200,111201424100200,112130011100011], + 1100100220010122: [110202012100020,102120231343224,111342020011220,100314114322101,103100034001310,111222102243400,100001221021031,101322221001021,114031010010210,100010001032003], + 140021410010010: [110011414240022,102100104000040,112132434020310,100000144104100,112120224040040,103301410110110,102124031023100,100204104320231,114002104020100,102311011000200], + 1000021220012121: [102032031130301,100013401040442,102410234024100,103012134011120,110412412010034,100101132014001,102102024222122,144012013212122,111204203012002,122300240121010], + 1403201000102401: [101421100301230,102130124130100,102022020204430,103214021400010,114003422304142,100012401020212,110100022010014,102000324011143,111110420014032,100003131040012], + 1012000230000340: [110220100000102,114042102330002,100014001041000,204020131034103,114113404003030,102310030240210,102200400234000,103001324012043,102110222004041,100102240020100], + 1001242011302204: [114010200011100,100102110412002,100000204214001,102022000220004,102310110213220,100012001042030,102000404000400,100013040404011,102004004004200,101002134011001], + 101041110002034: [111104102242110,100002200410230,100044010200300,102000021444112,100003010413400,103334120114003,100130204300200,110112131124012,102330104110220,101012224211030], + 1120014221202210: [103200021112201,102100200234203,103221021411102,110001214200042,112002242001000,100021111211003,103204020102102,112010204003014,101032240320040,112001302302020], + 240222400400110: [110000002100100,102022114004241,100200001000210,103230041400313,420011043004003,100012010410000,102302201102102,110222100022402,102004220201101,101210304043113], + 141300220000012: [101230002122040,110100041200400,101210241204043,104102040011120,111311120014011,100123011004113,100420001002101,101134224001001,102321234111310,102020121102120], + 111104440033432: [102124404001102,110032021010202,102202001300111,111221100003110,100401442201310,111000022230000,100400400022120,100212011212040,110100021302001,112042321111000], + 1121004142000010: [100300041001121,101240004011021,100120014100010,102303030241010,102202144110114,103002020142122,100022101001140,101401101012402,101002244012322,100000410122022], + 103211301011430: [101004200304221,102120214001422,101412300302220,110320002024021,114002044114140,101424011012000,110010444410200,102103101004410,102434111110111,100431000033004], + 1421032030120000: [101222101202341,110301442021010,100010024302100,100000011020412,102022400210202,102003034011323,111300000001323,110000002001040,110101000121214,100440441010002], + 103123320204204: [110301342021212,103330101403140,114102330211330,101021001140430,103000004001204,112124334023200,100000021232013,111344100003001,102141341340331,102132040202300], + 100111222201202: [102100001001320,111431114420423], + 1002000011024023: [114010034012014,103200031411100,100010004300024,100000324340102,114443200000122,114000102300102,114444124143021,102101000233100,103030024020041,110224104244000], + 1100021440000202: [114201010001201,100030024300201,101041404002420,102220310200014,103231224012042,100040300102020,102400110230001,102101011342100,110012404201130,102311210240013], + 1010200102002042: [110020301220324,100041000010302,102020100243032,100031001020040,100104001041200,101110404021211,103110041442122,114210400000112,114042014102321,103230134011412], + 312000302200112: [103300034021000,102441324022342,101041301000020,100010014313003,103220114040342,112032000201314,114240004002100,103000111403340,103102110210113,112120404000342], + 1011211122203013: [100202400434310,100000010002202,114410024140040,111221024440402,100021344104342,101011121032013,110000300444443,100203021000012,101001020321310,100221014121144], + 1021223331003222: [102012300212321,112400202023020,104400100142023,1320142020103004,1320024233112412,100010230021300,102230004030112,402014100021201,1002022012411300,214021333002200], + 130300011132214: [110100100101041,100420124100211,101040120320230,101220000040002,100422001002123,102314001101211,110140001300022,100212024232000,114202422323004,103120020221120], + 1400001010013100: [100000241020300,111021030042411,110131011000142,102401010202301,100201134320102,110000302122001,110202012020000,110043414212400,111110004101041,102021410242110], + 122101040014100: [110210221300113,110304014433122,110200004243223,102000010200200,100002330412031,114020042302142,113420011011140,102142231143322,110020122000000,112020402001012], + 1020234000001000: [103100030100010,102013110201200,100042000102010,112000230220102,102013000202010,100200001210240,112010022302321,101040224003400,102304111101041,103204101402321], + 1000310012004020: [112022420230003,114000044031200,102220204002000,112020411110200,100102011022214,101130000022041,100120110402020,101011030320023,100211004343003,112312002020000], + 210020111331033: [112024442000120,100100320100331,100024010200212,110200002122130,112002022302433,100010021042030], + 1001200302144433: [110322011230103,100023230123400,101020031114000,100021020100003,102340024021002,110112202001101,130100014120020,102000031101300,102142440202140,101021011140144], + 1434431010142230: [111002100000102,114021010040140,110220130100010,110203022032320,101300004233220,100300110110043,114000102300040,102011011130000,110434102020102,112020040231003], + 1100020142200241: [102010114022011,103340041403223,114002200000421,114302210010001,114030004104220,102443211401140,100000221020014,102003224000022,100001111201214,100024311220202], + 1001020100031211: [110301442021010,110001332103022,100104004300024,112041000220020,111304202202230,110000002001040,100440441010002,110040310040200,100430440030020,100100124301211], + 1012140202122000: [101000011030111,1300040101002020,1142022100220102,1212333103010100,100103211002030,1001002042020200], + 1202200030021033: [100003211020020,111000240044102,100000101040120,102300000220000,102323320240010,100011200100023,100010044213301,100330204322010,102111211401000,100122124300402], + 101410041124224: [110112320021204,114000000030300,110302130004200,102112100210100,110011111104432,111410004401301,102300044020403,101113231111221,110020131231003,110411032122430], + 100143114302211: [104132212102200,104100042101431,101410241100300,102000114001011,102320031100120,110231011210112,100402420022220,100421010013100,102211414034011,102300300212011], + 1121240102001110: [100000304340012,110404211211000,114120004000010,102404000230201,114011012210001,102212014011000,101301101004120,100000311024240,111040034111020,114140212320402], + 120032110220044: [102240020200400,101210331023020,102101134004010,103240100102101,101011211002010,104110411304420,100222100412022,102140002000412,110043001201204,101201324232020], + 1404011014011042: [110021104200001,110310020040401,110202204430020,110310002221402,110030002130201,102103320232241,100200000000210,110200222111020,110111001302000,110210304220000], + 202020130110003: [100044301030400,111311402221430,111420230003130,100030100423022,112203301101120,111310000013103,101200000302112,100020001031123,100114010111402,102120124032210], + 201301020200210: [100002021042230,102122220214101,114112012310000,100120210410001,114043402214302,100000001020340,100104210400100,102002200200004,112011041133212,110402031313432], + 1124000010333132: [100001214301021,112222032444022,102012002340110,100000111104311,102001030200014,102132022121211,101002024003004,100040010002304,102200100234232,101020244222024], + 1000123120204200: [100042304102210,112202000411103,101040100302002,100013030100002,101203001010111,100310034310200,114003022300020,100031201030102,114201104114111,101041001003300], + 1010312311112214: [103112010213010,111400002102112,100034100124302,111112214101000,1320102201231021,112201011040200,101102312120003,100011221224211,1040000220110240,102221020200001], + 1100030122222312: [110303120102044,102120012001031,100400004303004,110002022030224,110430320104000,100204011002001,110020221320103,110121111202231,110200000103403,100000104342200], + 120203302122312: [111310220042301,112410434041401], + 1441321210011004: [102342214020012,100220024324023,100214104301120,104130011240303,110010000403030,100120221224010,110402101344233,101001011001300,110000200000133,100112024032033], + 104000302123421: [110401000034204,101002124040021,103021310002011,103010030100210,111203024411040,110422202110101,110003131322240,100112224231100,103020224043113,102030004010201], + 1111113302204330: [102013014013202,101000021142220,102121020220022,110020222000021,100021004302213,100133004030124,102021022002100,114100100220411,100100030410113,111012020024130], + 210033232000044: [103134014000340,101440004041120,100040210411102,101031214000041,100110004102034,114112020212203,114302020003041,102110014030002,114300132321233,110000140032001], + 1021000000413120: [100000004102001,100201030430140,110203224240202,100004024100043,102330001104103,100200241000143,112004002314010,100241214220112,110033430011100,102300401100413], + 1000002320240103: [110021104200001,100302141003012,102004441124110,100000301221024,101224322120022,114100200002120,110310020040401,110200010014000,110202204430020,104120221240413], + 1024110020330200: [110331400400440,114021140030020,111040300024044,114021112203114,103124000104424,100100201043042,102011011341100,110130201011011,103220000100002,102010010223000], + 120413001003011: [102424204043100,100113220020101,100300211000020,101410401010030,103210241422022,103240001403000,110020124200230,100042034202031,102103100310300,102012014002001], + 1103200132421324: [112213000200301,100003224334120,110204130004030,110202120003032,100322004314021,102343301100440,102410434000220,110110440020002,101101000330302,102020214010123], + 100011004110200: [101230002122040,110100041200400,101210241204043,111311120014011,100123011004113,100420001002101,110201134243240,102321234111310,101004010323441,102000024000002], + 111020032003204: [100021204100204,110211020000002,103002034034022,111230214102412,111433044442220,100113410410320,111201442222420,101000004013020,114012000022010,114222440003300], + 142110200030101: [102301004011202,102000201100400,110034120023130,100110010410230,112121040200102,103000101240211,110100004223144,100134044003303,110220010010120,100020311230000], + 111212000241041: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 1002030001214342: [110022002120332,111110230014001,100301101000021,110020140044140,100000301031020,102100104000244,100221000031141,100420031002301,101311010340421,100011301024003], + 102042301201101: [102010202004402,111130312211003,100141214304000,101001010300404,103340004020422,102410220200004,101224044041002,102103214000210,100320114314042,100040400401001], + 101220410201134: [101301014221122,114220040000201,102102204022310,100404400013222,110012130410040,100104101200201,111040100020010,112201010203210,100000214310412,103042320101230], + 1000121020140020: [100003021033300,100142010410011,102110020202330,100001010014420,102041410242244,102101220214011,114001214100103,101200004040021,102323201000412,112102314020000], + 131231200410101: [102334004110232,112200102024122,103000034003300,112300032000100,101000100322140,114010010002314,114124002341030,110302322102041,101300004231010,103122214003002], + 304410114003421: [102001231413224,103003024011120,110304000402222,110001141011223,101211220310040,114210010004202,100020041020122,111132244101222,100114234304200,100000220002002], + 1022000020300033: [110001030120020,102233034000002,112130004021000,213002142300033,111212024101031,100222240004231,102112314002011,100030034100004,102241414034000,102223001303020], + 1100002202412323: [100012400101400,111242212222022,102022411100012,100020100100300,100001210102104,101401140300101,101242000300000,101030004004303,114102404120000,102004021442313], + 131220420004123: [101232314010241,100301300121100,103020124010320,100021300101201,110230022122031,101000444214021,112102112301130,100414004300100,112102232300222,102200000201120], + 1020200240302400: [111020030040120,114301022320021,103344200113430,114101104102004,102440024022132,112100102012303,112003402002003,303020404011031,110432112113300,102012044013241], + 1020412223013431: [110002342100014,100301300121100,111101042244210,110124002040002,110023410122402,110042400130000,111200020004203,104101201240100,110000011012202,101001040302400], + 1440032123021120: [102231130213210,100043324210140,114113104123200,100023024211011,100003201021001,110002021121023,102300040221403,102201100200430,100114021040000,114121300224141], + 1002100401302020: [111330004130112,110000042002101,110010240442010,100003020422102,100120214231002,102001210221210,100042011210421,103020024001001,102314140212003,100003014204122], + 110200000021104: [112113214020100,103300344012201,102010202004402,100000130013400,111130312211003,103224041400220,100001321032243,101001010300404,100201104224131,103340004020422], + 221000130210110: [100020120021020,103001101422010,102100411121420,110110200000021,101324104210010,111001400043101,110444020400110,100002210000012,110400110001013,100013014310022], + 1001002313402301: [101240421023020,102110200202220,111031014133130,101020401034001,110103402012010,102440214020040,110004124203400,114010100001220,112022102000012,111000430020000], + 201010021240440: [100023011001021,100122204230331,100010020003124], + 130200020232002: [114202130211223,110110242112211,100033114200011,102201130200131,110100111221242,111110100010302,114020202201002,112002024004122,100410040030230,112120110200240], + 240041203020200: [101002200301130,100004431210220,103401034002022,100113211221220,102204000232030,101004004000320,100011344201241,111111002111301,103110404002224,110400130400001], + 1114000002330402: [101000224223002,112010012000201,112240000413000,101040201112304,100100301021212,111011024411424,100000101223200,103001404042022,101000231002312,113001320141134], + 100212132201001: [102010114022011,103340041403223,114002200000421,101020321002002,114302210010001,114030004104220,102443211401140,100000221020014,102003224000022,102301041000014], + 112111240000140: [100023421041402,101010224000130,101144134001102,100210020410010,101000414002041,114034422302101,110421104242000,102322004112023,102112404030400,100020140002030], + 122220212021024: [112241020202432,110443000000102,102430100200123,100100001013001,112401002022010,100004204101200,102001004014032,100403001011201,102002001442000,101002024002423], + 124040202022100: [100400002201113,102420424042020,100010001032223,102111024000402,114321002320001,102001011100100,114402104142102,102122412001012,102311120222404,114020404020132], + 1400014000001312: [100013304331301,112000022302210,101132101110121,100002441034002,112001001132010,110221412114120,100131241204104,110111242012201,100041411223021,101220024232404], + 102040442400304: [110141010001110,104122011242020,110213401202210,111103310001234,100110441001000,102312000240002,101202124010000,102012104010301,114123014001020,100004004303030], + 201021122032220: [100214121000000,100002244244011,102011041100210,114323000000130,100424104302020,101013234000010,103210014003000,101220441204300,102011112000100,114120134101111], + 230002034010432: [102430140202114,101414014042200,102120001411020,100124144230110,100040100003000,121443142030222,102040011100303,112020322003421,110304022101121,142001100014020], + 100120242322132: [114101024120020,102004011440212,103140320213200,100000001021013,100011204300012,100001021221000,114003134011032,100101234330123,110024000432310,102012101443110], + 1002114030300320: [114034030020130,100000301031020,102422310203100,104134440011201,102311021104000,102104220213400,114224200210241,101010244002013,102343001000312,100001200102200], + 102421001141212: [101242011000124,100202340430142,114420242311240,110141001301302,101200200300310,114011402303024,112124000203110,103330201404321,102104212003342,102020004000040], + 120014211020422: [110100000124440,114233242330032,102012004002430,102020000204042,100241101003430,101001224000033,111020120042200,112012212310300,103000301221001,111020122111214], + 110102220300102: [101021020331240,102131221410130,110031011310220,100020400003003], + 204242212230220: [100222004320102,100110004103122,103020200141000,102414034040100,100022304302043,103031300144042,100120010421220,100000111034100,103132114002002,100412200002013], + 200041240220100: [103000230120042,110111001300044,100101141042243,100101100022012,102001221100211,102100132000411,100220010002421,101240204233201,110320100402023,110220411214021], + 1141300003000001: [102000001132113,100222004320102,100110004103122,103020200141000,103031300144042,100120010421220,100000201041300,100000111034100,114011200003102,103132114002002], + 1101044004001200: [110100200030100,100000411231000,100023001222000,101002124002220,140300020110000,100003301030120,100101004230030,103044004034040,102300231000210,114034000012210], + 111400020211110: [111130224102101,102322020212020,114403304140021,100031131042030,112201422040000,114413232320000,114024130031020,114022300011000,114441124140100,114000002330112], + 1124411200202010: [103140114002241,102000301100100,101300414221100,102331201001140,102200230211200,114001042203020,112220022044223,102104411412302,103010210142002,102301010220021], + 1240312210020202: [110441140102024,101004120224442,100413311002132,100320421001431,110210301200101,111131102210013,110400241240242,102210101121104,110023102103200,102400140230123], + 1100203201112130: [102034011133220,111001004401004,102011001104040,101310340314200,102100101124222,101001001000001,100204421000010,100010111001330,100110041000011,110102320002010], + 124101120211420: [110011011212100,101134030011000,112000244001222,103220211421421,110123230124040,101000014012442,131000001020102,100301311003043,110430014221230,112200412033030], + 1040020120321030: [100222011211021,114031112210241,103201114030123,100002430012110,112000312000120,102120341340120,104134440011201,102311021104000,102104220213400,112021011112000], + 1002304404022010: [101201111200422,103340404020014,110104101003002,101201101022211,110021201011130,102100004004440,100212001004102,100011414310123,100231224330202,110420432122312], + 204000022400011: [103134014000340,104103100010141,101440004041120,111101222240010,100040210411102,101031214000041,100110004102034,114112020212203,102040140220220,114300132321233], + 101120020032110: [100021330000403,102004420240202,101302040341100,110040000001400,112101400230241,102110424004111,114100020221400,112020102003000,101003010300000,101020014210000], + 1010402034220214: [111102420023101,102102244000330,100203101000022,114114010021023,101000000320000,102310204033140,112301101134120,103022000112300,114220212340004,100004240120000], + 132142224424211: [101043042401310,111212022200012,101113012101010,111412020003222,102022102010211,100021220002020,103010441402001,110302242202220,103021020002400,111121004402312], + 1133124014424100: [102002104014022,102041324001010,100002101021040,111200112221320,100000331021022,101400314042120,102011200242200,114244100003024,102410101112322,111331440000120], + 1142104430233101: [112413224040101,100220100110400,101200031020230,102403004042342,101024001034211,111122004101222,114020040013100,114001012300002,102121100232012,114000222213021], + 120221110220221: [110120144200000,114022412330004,101200221022044,110241112020204,100002004104004,102100224000210,102310140240012,100014204201000,102103321411004,100400001001300], + 1002413221231220: [101130000023030,100200400000010,101221200010202,102100014031110,100040001022001,102421340201120,100002204300121,110004342121110,100100340412100,111430002210013], + 1030230031400411: [114201010001201,100030024300201,101041404002420,102220310200014,100040300102020,102101011342100,100312131204422,100012230204000,110131214220303,110143101120300], + 1013002311002010: [100423004302232,110030220000310,100110034332223,101223100300200,102001034002201,101104401020410,102032031440302,100113004304010,101310311000124,111303214132004], + 224200010200220: [102331021100100,103223014033210,110201124221001,100002001211230,114410102321111,114101004121222,101100234021102,114121104101103,100043110000201,110400112210122], + 1110100012011004: [112000202000231,112003120213024,111212024101414,114204304101001,111000200000302,112301132022231,110422234241202,101401241102000,100000324200100,112002144000010], + 202121012000121: [102400111402142,100010000002400,141030301403400,100000024100211,103224200113121,110140101300004,120020211120020,110230010010142,112003000230111,102031111324402], + 1000103100411424: [101400220300033,100012021032040,100012021040320,102130224023220,102100401143124,100010001030140,102110101410144,114142204121324,112102421102022,111320134133110], + 1001412201332002: [104400301202200,100030010000110], + 1412201020041112: [101032104014144,102120214004010,100022041030000,100402020024213,102142140313104,110410020403024,112412300200103,103023141400000,102443011400041,101001100300012], + 1201000121400404: [112004202302034,103300004021200,102122214131011,100023031000024,114210400000112,103230134011412,102021021101204,100231020102202,101000134220400,101410020300143], + 323234033120000: [102010130231400,101000041031301,101010311003410,100020424214024,103422430124013,103214400131240], + 1010120203003020: [101142400332243,110002001321022,102302004110032,101401204021230,103100010101002,102041201123423,102121014020030,101010221020404,110002034410423,102100220214002], + 1100413031100310: [100321004011041,110002342100014,100301300121100,111101042244210,110124002040002,110023410122402,104132420010010,110042400130000,100114111014300,101001040302400], + 1121101000401320: [101440004041120,101031214000041,114112020212203,114302020003041,102110014030002,110201200000101,110110000032030,102001200204101,102033340222200,110042402132412], + 1022013143100000: [102402024000034,103012024004312,102214020242110,100400212200322,101140320330114,103221021412001,100000204100304], + 1110300004201222: [102023324010020,114000004103003,111131002212014,102110100233222,102120311402124,103140124002022,101042421021120,114013204013220,102000100221400,114241204001213], + 1242030100001103: [100010104331200,110100121224222,110002142120000,102011011321024,110100100030303,100043100103044,110121202010001,110020001300130,101120020304200,111242302220133], + 120010202000102: [110340014422102,100231004220242,101202010301321,100021210200200,102304024110004,100400102040013,120020430310100,143112400002321,112301043200001,103040110122010], + 100021140440004: [110000001324024,103100314001030,114101004121020,100040301042132,114010040023411,102001010222103,103300024014002,101021104212100,100000101030412,103031000121000], + 1042102220010314: [102000020223013,114040102301100,102310111001210,100020241043022,114413232320000,100100001040134,102100121341102,114000214031012,100002004130101,100301024310020], + 1110230020120320: [110103004402010,114010102301042,101100101114012,100210004104200,110210004220432,103201201204221,103100014001341,111243122210304,110403400034011,110000012031000], + 1010300040002400: [110330400010040,100101231004020,111000100012002,114102024123030,111102010012102,110013112004021,100143040411011,102404404004104,114002202302000,100034000000002], + 1044432423241010: [102400111402142,100010000002400,141030301403400,100000024100211,103224200113121,110140101300004,103103221421013,120020211120020,110230010010142,112003000230111], + 1100200011104310: [114000242200010,110000440420040,100004100410134,102011201412140,114000300014032,100041121022141,102100100220230,110400032220312,103334010111101,102010200223020], + 1010403000012130: [112233000410001,100021214200024,110102044223300,101022114002010,110402042222042,101013404000212,102121430200100,101001411000403,100123020002000,112121212311000], + 1102002000204044: [110001022000001,110023342101220,100021004310222,110020422131120,100001000100000,112220322030220,110202222043022,110313312021120,102223400201104,102342120222031], + 131130200220211: [103100221440010,114003344011001,100021101000000,102140000212141,101014201030204,101203001010111,100031201030102,101041001003300,100001100411302,114012444020220], + 103221021101110: [102401021402212,114400044140001,114120204000410,100000001020000,100031011042040,104312001303013,101403014021204,111224022220121,102022001100203,112000224000141], + 132200120000013: [102000220220104,114202044111100,100030004102002,103110114000220,103200021402002,114001200041204,114020114010322,102030401014002,101232444041012,100000020102121], + 132030014424412: [100440031001120,100020001041410,103220011420242,102032012000101,114014112302234,112102102302000,102141231343401,101231104200000,102112011401424,111242110002213], + 104040232200100: [102224101113104,100312331004000,103301244010210,114202144102100,100040310123023,103001220100000,112012012002100,114231200211200,102314001000244,114100000031020], + 101202011120011: [102322014113341,101022104001221,110021422000000,112021004003303,101120030330110,110331012224112,101002200301130,100011120000004,110224130002014,102300030220022], + 102011312440040: [110210134244100,102121041441000,114102022200000,110233010002020,111203034103022,102101304000012,114020202241323,110004402131000,101240024012131,100020114100404], + 1022413300441010: [102000020223013,114040102301100,112121032014014,102310111001210,100020241043022,114413232320000,100100001040134,102100121341102,100002004130101,100301024310020], + 103101430414310: [110302302001423,101010101022202,100013211002142,102211204000440,100200001001420,114141024004011,114140044002043,111030424400000,100031101031110,110202221212123], + 1000100422231213: [114214340000030,100022214102211,102311204021000,102314244114310,100000224300120,102102004000100,114200002341010,100024211042404,112004440223402,101000000304012], + 102130202031041: [100301300140011,100030031220122,102211104033011,103210000102210,111140000012120,101142444001020,110103010011301,101010404001431,103012204004212,101100044004000], + 1004311100312100: [111211312220002,100001001033004,102014100241300,100001111022110,100000224300120,114200002341010,100410100001321,114101020000102,103030030142013,100000230122114], + 1000000012202013: [101133001104410,102301001004020,100341130142101,114202424001100,102100300210100,1100000411441420,1002203010011112,402001100011120,100020321030202,402202000003002], + 1120141011000314: [114000044020204,103044010120003,110142020400012,100142011022211,114230344103210,100030020104423,100000001021041,101000401032212,100004104241121,101303414220001], + 1101120311023104: [110104112010103,100122004300410,102202414041044,102140014001101,102000104012232,102021100220101,114443330001442,100230120001003,112203221102231,112400202020003], + 140441202010331: [100024041022000,101000020303402,101011204212224,102230320231031,110002304200001,101040000321200,110004311221102,100001324100210,101021210320211,100400112201310], + 111040410100314: [110011232100412,100220040142222,110232002101410,110020120040121,110200021210212,110131021240303,101040000301210,114240000001020,102130034023112,102204114114214], + 310040300000113: [100301031002201,100000224311320,102120121212031,112000400223100,112022411112104,102022031324020,100211111003420,100344041000232,114310332300121,112322031101041], + 1100241233220112: [103202004001120,100120204003012,1300022002310414], + 130302420200021: [100030200102434,114100204101002,101101230010000,114103204100320,114100020033022,114020012300203,102112410222200,101141041022031,102002100000102,102000044000420], + 132001404403001: [100024000110221,101000130320340,100110020031042,110422102110221,102102204022310,114130014001202,110010220103020,111004100022110,101002201140040,100211000412142], + 124232100100022: [110202000002301,100021401041100,114020000011320,111020032203301,114002204011413,102010111411204,100021314202402,103040020122222,100031001030010,103433144040432], + 133004121000421: [1010400230221020,103034010121101,102302200210010,102340120222440,111300400002313,111101040014040,100023014313010,114021040010311,114140004123122,100002301021040], + 1402123103101200: [101434020303202,110220134241400,112014002000221,101020030341241,111421002210211,111110022240013,100100301004010,114302202304141,100241124022420,114404200002303], + 110040410040202: [110230231300100,102010424000101,100300121000420,100402431014100,100100001220400,110330200400021,102220324011110,101423100300002,103111300102020,112202012030100], + 113200102232043: [102222111120010,103200224033413,110002220002220,102300440221022,102320110240231,112100140200020,100133001220421,100122204301312,101000000300323,102024001102302], + 100023202232320: [100000220100001,100122230031414,210303212040010,114222042332003,100000014200104,114011120024030,100101121010100,103002011240201,102440024021100,110110420034120], + 1111032110212102: [103100214000130,100002244244011,114323000000130,114040410020022,110033020003012,110023100420044,102102121341231,103210014003000,101220441204300,100014101021022], + 1020002322133043: [110340014422102,101022400300001,102140004000100,103202130122102,100021000010213,100004101033223,100231004220242,112430010114123,130020100202200,120002101133400], + 102310411200002: [101220111020012,100000214101311,102200230202120,114200020003000,102012014000404,111130204100040,112410202020240,100033131043244,103000024040413,100000034344404], + 130110221101102: [103140211443110,100030001020201,101302401003202,114320100002004,110203221112042,100004004102002,114330100000020,100204220000112,103210200100000,100000001020344], + 100020213340111: [100423201003400,102010041320010,114000230023300,100020104102410,100423110021010,100010301032022,203110200224013,104021120012202,101002010323401,104202101104231], + 123020311240204: [110330400010040,100101231004020,111000100012002,110022140120012,100143040411011,102404404004104,114002202302000,100034000000002,100400100031022,110020130044232], + 1021100222040004: [102334021001211,114123420002142,100000001024010,101000304000400,101204031024110,111310000002001,100010300100204,103131004000400,102000000222333,101221004040204], + 1422043004222012: [103242420100012,110224044242243,101400004022112,102200000200201,103110020210000,100022141030334,103200211410311,102100404021014,102303001102431,111441004421100], + 1430040010410020: [114000000032100,110140102142200,100110034101010,114341024032221,100400444100202,102004000201030,112020401130100,103122301212000,101000141004421,102201020201203], + 120114201000022: [110101210013000,100404121014002,101240220300022,110120020002304,100011000202214,100000024100000,110212214400114,110012101102100,102102304001200,100010040001210], + 1003230011201240: [110100041200400,111311120014011,100420001002101,101134224001001,102321234111310,101004010323441,102043001021033,101210211022100,110421202110000,114230044144111], + 1004104302020210: [114120304000212,101042041021001,100010031232443,101211414040000,112000022310414,112010030221031,110012000000201,100001114011131,100102001220101,101021004000020], + 101000203000121: [110420200000430,102303044033020,100310000422013,100101144231140,102220111123300,100040001022100,100110311000421,100021420004400,100400010013210,100030424340022], + 1021220430143000: [111123010022304,112003001133011,110213002132000,102022420220121,111010132204402,102401214020202,112102204024002,101000131030120,100001301214030,100101000403002], + 1203010120120014: [100222011211021,114034030020130,114031112210241,102120341340120,102422310203100,104134440011201,102311021104000,102104220213400,112021011112000,114224200210241], + 102202402300040: [100000101040120,102323320240010,101022344002202,102112101020021,114313044003041,100030141000000,102011101320031,102013000200442,114024222212420,114201234002300], + 130340001031001: [102310000222133,114111000222110,112034040231012,114104310000002,102100011413420,100001001034141,112123102010143,102130201140012,100010204202202,112422320200210], + 1421200201043101: [114020420040020,102103401140000], + 1404022242211204: [111012344400410,124200301323001,102230430231000,101000031034024,132013121201314,102100010230140,122030001033422,111020324410032,123110100001324,101000324000302], + 101411020202310: [110214024430312,100011014100041,100212341003212,112010220224003,100200001001300,100012104313201,110212310000041,100040424310110,111301332200104,102141424030044], + 1120202100022021: [110003112130100,103000230120042,110111001300044,100101141042243,102020440242023,100220010002421,103222010114132,101240204233201,110220411214021,100110004332200], + 132411000001041: [102021024000010,114032424122040,112011012004300,102000401120420,102020004001311,111201210000103,100101101010100,102321044112101,100022024100041,102004012043122], + 200212000010200: [114021412213020,110030002000422,103100014031411,110000300424304,100032121024110,100402431012022,111403100030130,102022400211311,110030400004330,100401241014100], + 232120404214130: [102334021001211,114201104114111,100001100411302,101414214021020,114123420002142,100000001024010,101000304000400,100000014202111,114202104001212,100010300100204], + 222202400430420: [103102101422031,101421100301230,102130124130100,102022020204430,103214021400010,100012401020212,110100022010014,102000324011143,111110420014032,102042231130200], + 120310030200000: [102011121131022,111320010000021,100010214101101,102010202002040,102131300232014,110231202044211,103022001220121,110013122103220,112214100423320,100000320004100], + 1002001240012200: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 1103223420212310: [114010100020041,103102314001204,102010021320410,103222120102031,102121224004000,103100110211001,101002031032000,100012004103100,120014120001010,100401130022024], + 1043132202104022: [100020214300031,111220030010210,114042034104243,110123111300000,100020031041304,100412030034000,110100302010110,103232114040140,114010002240111,100002220411002], + 110420020014300: [114430324140000,103100010212020,110000440420040,100402200033000,100040001031332,100043404304202,102403100201234,102222121000433,101011000302004,100041121022141], + 1113124100141410: [100023324302420,103111201422013,100212024121000,100001001033200,102001024012440,103201000102140,114010112330000,100033200000420,101304004232410,101330104221320], + 110304311000201: [102431111110001,102013421100201,1003002030122040,1320124301012211,120204110000223,1110002442211200], + 100010030110010: [102402201110020,100001024100241,102000230224024,102103120210312,100111124101112,100011120022122,102243200200400,102303031001200,100024100411020,112001010233001], + 1004234000041422: [101440004041120,101031214000041,114112020212203,114302020003041,102110014030002,110201200000101,110110000032030,102001200204101,102033340222200,110042402132412], + 1031112024100002: [101010001000031,100021020104221,111120024101141,103201214021013,110310304430141,102113304130002,102000131131100,103124420221210,110201002043201,100011034302423], + 1020120002011140: [102114340204022,1303043020124234,114403402311003,111143400421100,110221310000130,100223331020012,1013001120112020,1311314200100310,101042020300200], + 112020313202420: [102203344011410,100021324100000,102103430210003,100012014300120,110100120400020,102414014022212,100032000101014,101430211012120,100204021000012,100032134101100], + 230000220100214: [102442211414022,110104231221040,110401440001204,114400322311044,101021021002110,103224401422304,100401140033104,111231012220013,103214220100013,102411130201102], + 1404101340311414: [100012230204000,110143101120300,101101200311102,112401402023020,103142104001331,100200204123011,102012024040044,103031120143010,100103401003022,100000010004223], + 1121211121220043: [102041310200042,111333104124202,101000304014100,100040011023101,110301030010140,104100002101431,101123232010002,114421242204443,110100222001100,103102000121300], + 1200200204310120: [101021120323020,100102101000203,114111200034310,100001021030011,100021030100001,103230040101112,100010041032043,102321021000142,102441311400421,112030004021010], + 231242124121002: [110420020103322,112400204042221,110400431001201,100030101232000,103122404000100,101140030330020,110030242131210,110142214201120,103202411411014,103232211412010], + 1003212121102021: [102442211414022,114400322311044,111231012220013,110022300420031,102340301000304,100101220101011,110000141123103,102011200242300,111121000014100,100411101001140], + 124120122002042: [101012041102300,114020312240022,101030101032311,110103100400230,100420201011001,114100234000001,110222022042422,101042024011422,113000011000002,103140120112032], + 122020101340442: [114002104014300,102000311102212,100130320031042,102010004040000,112433112020200,112301312020123,102000201101332,102231041120104,100111304300020,114132420004104], + 100210004242020: [111312000000403,101212040011001,102312010211010,111011242233002,100000011041021,111110223004100,114313200211321,111321010040420,100120041224204,103004024040430], + 1024032020210011: [102301004011202,102000201100400,102001301132000,110034120023130,102101004002000,100110010410230,112121040200102,103000101240211,114221040210200,100001320404030], + 131001120002020: [110200400000020,100324140141402,110000112100402,100002204340200,110000410001034,111140000000000,110022002120332,111110230014001,100210200034304,110102111204210], + 1240020221213240: [111431110000042,100302141003012,102004441124110,103303201400021,100000301221024,101224322120022,114100200002120,110310020040401,110200010014000,104120221240413], + 1110110204200213: [100422211004214,102100000210002,102121010210004,114013214010111,100010004210020,112002100240200,100001404100110,110131022014120,101213110310042,112000002000110], + 130224120311000: [101423400300400,103140114002241,100024011031110,102200230211200,102221002020200,103113211441220,100000000120040,102001140222341,100010320201332,100004200100401], + 210400014012121: [110013202003320,101031241000010,110030332100203,114404232310120,103100034001310,114002202210331,100031301020100,100020010200022,110011300010031,110002401102404], + 122003012201010: [111042000041011,112040232002301,100023124103021,102120411023000,102000000240101,102020040223423,102201110212212,101111201110101,100031030000000,102020214011010], + 1000322104241421: [114002104014300,102000311102212,100130320031042,103110021442200,102010004040000,112433112020200,112301312020123,100042001020203,112221200410000,112023032000020], + 120004010022330: [112112014020002,114101404004011,100004414100021,103020241402220,102023110212012,102132210233141,102113101342120,102130241400320,103210124000001,100004340100020], + 1012214202111102: [114324100000120,101004301142000], + 213241130122220: [101020000300112,102203344011410,100021324100000,100002020410020,102012220241003,111120214102000,103130020213032,101430211012120,100204021000012,103302140112020], + 1101400342112001: [114033234032101,103001020120202,101000020302400,114200004110030,100101004301032,100030124212213,114210102320112,114234004112000,101000201034000,101032000312430], + 1421240440043000: [101440004041120,101031214000041,114112020212203,114302020003041,102110014030002,110201200000101,110110000032030,102001200204101,102033340222200,110042402132412], + 1130014010430330: [101221020040220,100103104302044,101041030320401,102141212000200,101203121020430,102020004000014,100000211023014,114144014122041,100201111002224,101410304041000], + 121104244203004: [101221020040220,100103104302044,101041030320401,102141212000200,101203121020430,103130021444021,102100104002224,102020004000014,100000211023014,114144014122041], + 1022000400011001: [114430324140000,114000242200010,110000440420040,100402200033000,100040001031332,100043404304202,102011201412140,102403100201234,102222121000433,101011000302004], + 1030222114123230: [112311011101001,100210201001001,101100001101401,110100124402042,111120402212201,100101021021114,100210010430242,101411001011011,110040212000010,114102124000200], + 1112033100200400: [111304340002030,110102000401214,100100111044040,103140014002031,102024102020000,102224241110003,112003020220120,100043024210301,102014001130100,114022100010000], + 302323002003120: [100134120420201,101234100301031,100010111020010,103021321243004,100400130020130,102201144002030,100340040040204,101321001002122,103002124032324,114200100210114], + 1420231001032130: [114402404141241,100200400430003,110212022133311,101041210311410,110022004211030,110403010000304,101210021021243,100140024230240,112230240412241,110000204203220], + 1000000200001104: [102121221343020,101010101022202,112104424022201,100013211002142,1302314034023041,102211204000440,111030424400000,114140044002043,133010044232231,100031101031110], + 1014302220020110: [110401004221204,111112000011222,100322444314002,101003301020022,100001030100030,112012004004000,112044204000441,103141100104002,110341300400201,100000104210240], + 1102010140134300: [111200200000232,100101001011114,101430004040203,102210314111120,100032300010000,114132302200001,100013004300240,102220024122101,112022140234004,100143440001301], + 131000301010041: [101033011001100,103100020210002,101011010320431,100100004230402,102110304020201,102321401104012,103041414001042,110202420004101,100021220010031,100000200100141], + 1020020212400020: [102300000211330,101011210314200,101211411020304,102314311100010,101000320320031,101040404012102,110042042002231,100400142200202,102110021342220,112002000222230], + 202110244030013: [103301244010210,103001220100000,112012012002100,102314001000244,114100000031020,100003124211410,102401024020221,111231012242301,114444004140210,102220210203210], + 1110431212111101: [1302314034023041,112012200120020,111041134000211,1124042220104011,133010044232231,1303040444403010,1100010110000012], + 111412220002130: [114040002210432,100010040122204,102001420220112,101422214042012,111000302230320], + 100423433212000: [110010334200041,110022004410312,100001024102001,102000401442010,321114010100340,102322101000200,101020041000102,102110100322014,110413131000201,112012002302100], + 1001203222000011: [102000000200302,112204134010100,101001334211011,110001222134013,102021120200111,110442004241010,101400304022340,101232140302001,110020302131112,110101431000132], + 101311221003141: [100021304300200,101024000321043,101023124002002,100020020102201,102111400210040,102023001440404,101023014004000,102140140230002,110412042010210,100001111040010], + 1002031401231123: [112000211111200,112102032012332,102010110200012,100112034232204,100102401041104,102011302002010,103103134000123,100121301013301,101000424001012,114200000002120], + 1004030022102013: [110230102122422,100013024201330,110222131200214,100000114332021,114000010020212,112002014003103,112120300420042,100100104100320,114201340002220,100221114121233], + 1022021020020200: [102022004012201,114201104111034,111130210020000,111102042213043,100000024210130,102300104110002,100024000101404,102041320220204,100020134212021,101201004203204], + 122303300001400: [100032304102001,100013000001010,101044024044020,110110121320433,110324201302001,121000140410003,111412332212200,110303202000004,112400132300000,114100102340042], + 1100330240101014: [110202000002301,100021401041100,114020000011320,114002204011413,102010111411204,103040020122222,100031001030010,103433144040432,102310201001420,102420321400201], + 1024002000220210: [111420012101422,110444144241024,114120030020202,110201002010420,101004020342000,100230410112111,114224012330022,102101124001310,110201002110202,100130001014110], + 1040012120204001: [114020202300410,102140201343122,100121100402000,241220023100031,123010242104441,100000411233303,110204420000422,102030014012023,100141104230230,1000200011141014], + 220430011210404: [110013202003320,101031241000010,102120231343224,110030332100203,100314114322101,114404232310120,103100034001310,114002202210331,100031301020100,110111032140220], + 1200300401420001: [114120430002002,100000100120300,114202244112111,100031021033010,114011404103142,100202121000302,114040002300000,102110230224231,102002430222010,112101040200013], + 1022200300012222: [100110034332223,101223100300200,101100011201440,111303214132004,100001000100200,100003301003304,102201002022002,112000000220402,103001201221020,102042100221020], + 1102024000211320: [102402024000034,103012024004312,102214020242110,114102224104002,114422404110312,101140320330114,101010010300020,102403144000120,112120020230024,100000204100304], + 240120103310240: [110004020020022,114032412303041,114322024034312,100100244231020,102143432000102,102040010200101,102200434012013,112000301122111,114001110033210,102100201400122], + 1221010200000200: [102304030220001,102222320200001,101100021101232,101010001000432,100134101022112,103310200110020,100020031030323,100001001032400,101011411002311,102101221414000], + 204002010230203: [110100120400020,111120214102000,102113200210140,103130020213032,114030000030012,100000010202201,100111404302321,100012024210210,110200210102240,101040240320200], + 1040101300002402: [110203022032320,103142021211011,313040122221220,102002240241140,102121030212020,114411024142133,103004201240410,100022024340200,114020110001011,101010330320400], + 1110230402120404: [102403004042342,111122004101222,114020040013100,114000222213021,100000020401302], + 112204012420204: [114212104110100,102242201000222,100000104100102,102001040222000,114004202210130,111103214104101,101220000302410,100004210412101,102102042002001,101210321023022], + 110042014000222: [112004202302034,100010044300003,112120224040040,111321314133000,103301410110110,101131024020440,100231020102202,101011211003002,103014004012401,102000401100000], + 242041312101210: [102143124001400,100011011020440,101002121000111,100033134104200,100000201024213,114003422304142,111001404112102,102010201122000,114011042300202,101400031014311], + 1004002011241402: [100042320001030,110024001010110,100100014300230,102043104010014,100001004300242,111120044100110,102200201110443,114240314000100,101002411030000,102002324011002], + 100203420211214: [114343002322014,100022314100104,102130314131401,114100022342130,114300010002100,110200002031302,100013024312024,102002020243020,114002002300201,102040021121030], + 1003310202401140: [110202012100020,102303010241010,111342020011220,100314114322101,114032104100141,102021401324232,111222102243400,101004410311232,101201034010420,111220410010144], + 1020022202100014: [112000022310414,112010030221031,101010001141222,100221414100030,110110210012111,112122004020414,102000220204011,103000000141102,103411404020440,100001124311011], + 201012420101401: [114411202310423,100011041020300,101211024040010,100400200020134,110303202102200,102110010204021,111242020000400,112230202030200,110012104411212,101022324011422], + 142411340002140: [101100230013304,102330420243012,114011024102042,102310100240232,114230200210013,101030320340141,110020312200022,111302222202200,114003304110004,114311102301101], + 1001400040022014: [100022021024200,101012011001200,101222000300004,102142020212310,100102204301113,114100220004120,103234000104020,100100030024103,103010420140201,100022401001413], + 201203111010202: [112413224040101,100220100110400,101200031020230,101024001034211,114001012300002,102121100232012,114102330210021,102140320310003,111001100020413,112203101100310], + 1000301000024240: [110302302001423,101010101022202,112000042000001,100013211002142,110104000024100,103112000120002,102211204000440,100200001001420,103042021223102,111030424400000], + 203040004000004: [110121100004131,102320000221020,110142020400012,100142011022211,114230344103210,103114211441300,100101020022402,114010100032104,102300121000004,114010212301121], + 112020030001000: [100002104302320,103100121423010,110031024200343,100110411011010,100021244103133,100020104104422,114112012310000,104110202100102,100113040414312,114002340024001], + 1402000222022000: [100041204212120,102113110210240,112423424042102,100320431000002,102100300210100,102440100200000,1302011220000002,100401430030420,1300302112030020,100140221202112], + 1001102200311344: [110141104201032,101010401033011,103200000101342,110202202031122,100020140120213,100021000101421,103021110110030,110011042100122,112000000212221,110221402132200], + 110412023400422: [101022014222024,102203344011410,102103430210003,100012014300120,110100120400020,102414014022212,100032000101014,101430211012120,111311002224001,114030000030012], + 141030323100120: [114020202300410,102140201343122,100121100402000,241220023100031,123010242104441,100000411233303,101210001313401,110204420000422,102030014012023,100141104230230], + 104100100000114: [100012110101000,101202101000104,102311330240430,101023101000220,100002104103221,102231104040121,111331324131300,102303101002031,100010024302421,101022400302010], + 101231210201242: [101023020301100,110200332041001,114004020010203,114000332302320,102100221341001,100040004304002,100011301000021,100100001040210,102014001441210,100013224103322], + 101040022413224: [103304001401001,101210104011110,113422210102022,100112134032123,110201021102400,100030300121000,101200001022000,110021102002003,111124004102400,114022400041320], + 1030011204000340: [102210100313100,101200210302201,100004420014012,102240210240022,101040401032021,100102001040033,101242004043300,100002324211100,112100204041010,102024124011010], + 122122101400020: [101400100302311,111040120022202,102141000230040,110412220102021,102002400430000,101001300340322,110030024202101,110100224200101,101210242120124,114000102300220], + 313030240230000: [100112011020102,101021400320301,100404200020104,100122034231240,100200424301412,114140200220101,100020201024100,110202204244021,110101000014402,100202020433110], + 231203144121112: [100101011010340,111111000014001,100021320123031,100020001011422,100014041042003,101023321000020,114033400011210,102010221132220,103100204000400,100110411200024], + 102021300100220: [111201032220400,114203000004300,100022120412132,100000321031423,110322100104010,100031314241140,114043002302200,101222121020001,102120230230000,100032021041010], + 1113100032001310: [110041240000013,110131122012210,100012044101230,111021212200430,100021214210112,112010034020230,103021004011210,103120204002200,102404121400201,100001004200022], + 1103300304010114: [100010001030230,114130004122400,103313124020100,112440104040110,102221241110321,124301340333312,102302004110200,102200401112001,100140000410200,100022001042111], + 1400412113243302: [102041100200402,110400112021140,110112121002403,110122221240302,102241230200120,110400104222012,103302024010240,100001001021311,103001330110202,101002041112004], + 1021004121004222: [100111011011011,114014112300100,114030034013101,100000044204004,100002100412200,101013004001421,103000014011004,101020224210014,114202244101041,100122310020400], + 100200442001424: [100121020402300,100240221021321,100031014310301,110322240004100,100110001041140,110044102101103,100000104014000], + 1001133102420001: [102241041000242,110012232002103,112021324020001,111310120000011,102000024011022,110201111314000,111140222113002,103213224041010,110104040120242,114200114030134], + 100042233100400: [101001040340004,101013004002011,101300011002044,101011324004222,114000322300011,100002314302420,114411312312124,102121010212140,101010404213432,102110411342400], + 231002104101322: [100130011012003,110200000104021,103013010120103,101412304021202,101000421032002,102013001130300,100103234102402,112011400201204,100320224211200,104100000023040], + 1123420200203230: [1040014000334201,100020110003100,101310000020110,102220000230020,410010200103023,1001024230020021,100212211003002,1003101100012001,110420001101321], + 1114001214104222: [102100102001001,103113201442104,1001221041001000,112001000230014,114110302341103,100130210421420,110000302200313,134100011032002,110210010000010,1023200041003410], + 1000022002104011: [101210004011003,101230044012202,110301001232000,114000012334010,114302200002200,102101320234011,110010204412200,102400204022024,114412402323000,112032200211220], + 1100012020102200: [121021010114001,122100004114112,120003410003021], + 1221011220140010: [110020301220324,103040020122332,102020100243032,102012200202303,101110404021211,103110041442122,114042014102321,112003110242131,102112222001200,100021104100310], + 1020020030002142: [110122120100022,111100424100021,110111121011004,103001020104102,110200422113400,112000000223310,100002214210110,100011200201230,111001002201034,112024144002202], + 100000244124401: [111000022202402,100430211011410,110010340040012,110014032101430,101000030321102,100000001022401,112312330200200,112020004000202,110002410410001,114221234002100], + 110002300204100: [102021024000010,102300010242330,102000401120420,114011102210402,114300100000041,102222014011300,102101430203000,100100121010022,100002134204321,102114201120000], + 130002304020112: [110102224201130,103301201402204,102401121113302,100021020124002,102104131412412,114020312300021,101320040302031,102400204043012,114010102300010,114042014014024], + 1221031012020100: [103041220111410,101100202130022,111220032224301,103400104001342,111001212200200,100000331201012,111210214440200], + 130100014041020: [111120002211010,103122000100403,102023120241131,110014300041302,104103101240204,114241000002004,110020110400102,110321001330010,114220200214400,100400214321121], + 201041133020121: [114444244144110,114201004110120,114033234032101,100412114304000,103001020120202,101004411032102,101000020302400,102021014012210,112400000200011,111101400011011], + 1004010020204300: [102214204030204,101300000310011,103122001440001,111024044110202,112402014024010,101200100300130,100103000420004,112010040224120,101110104203101,102030214011002], + 1110102011003114: [110400000002213,101031104002100,101101230331040,114132100210100,100400032200141], + 221120302032122: [111240220002100,110030344201413,101001014001021,110100001014311,102304244110431,100011000201002,100103224301304,114000100020200,102100322001021,102102100231000], + 1022143001400200: [101212101023221,100024321221031,102120244001000,100002411024300,110312202000104,102022201132402,102411234021314,100110304233020,110020000020113,112040002004021], + 1022123131322310: [100002241040110,100021301212103,112222002030000,100020424302014,102110022001113,110001412102223,101013301021213,110420220002002,100124300031103,420244021031013], + 1121203011214032: [114022444101022,102201311121101,114100044004101,114201044032410,102141202001332,110002302200340,103000401422033,110041002001221,102120010204040,112021010230212], + 130103011103322: [101442104021041,102011030231024,100224030002340,101020004010000,102010320220302,100102011200030,101000010310021,101214001014410,114101124001020,101424410302410], + 1100213030400403: [110100041200400,111311120014011,100123011004113,100420001002101,103102104000031,110201134243240,111100044100001,101004010323441,102000024000002,102012014000133], + 1000403200032102: [110111222040014,102200004120034,102004204000422,102141002000040,103010000120000,102440234021012,110000011100204,103442014000100,102100021410210,100441021002110], + 1124020022021011: [101004201002001,103112010213010,102121001410120,112200410200142,101212000301013,111400002102112,100034100124302,111112214101000,1320102201231021,100000040413022], + 1000021310011100: [101020414010211,101120204002140,101142004000232,101410021100102,100110004101000,100040020201004,102000034000000,112400200201000,112002112002220,100012304300004], + 124441120130024: [100304201000221,100112021020320,103010001422020,102300124023122,114221004100020,102304100210334,100403210010142,112003100241220,102204304000304,100301104104210], + 122111100000201: [110000101304203,110040020001022,101104020300301,110010022003021,100401241014100,102101004000011,101401001010021,110033002000020,101200200300020,100432200030004], + 1430131234111200: [103132304003332,112040202003030], + 1020100000000012: [101020000300112,100002020410020,101000001111200,102012220241003,111120214102000,100402120030401,102113200210140,103130020213032,101430211012120,102323204113210], + 1104124230012120: [102010221411043,101020004011302,114212100023341,111200112221320,102011200242200,102300021103201,114244100003024,102410101112322,102121041340000,110010140011021], + 300202110012044: [100032041021210,110004301222000,102040011121100,114310000001232,111202012222402,111322234130000,102040041320010,110104002010100,100030024303023,102042204000300], + 120013042024010: [101101100330320,100000100000432,100400320020220,111220100000032,100121324230300,100121111000220,100113434000102,100020310023030,100033320410000,103001424002424], + 131024402202004: [102003224011000,101113140334114,100101400000132,100030310422011,103041020101400,111300402200003,102111000310213,114100422320440,110022410120230,103010101241110], + 1101322221340422: [111011030004021,101104020300301,100012101223021,101220330300003,110132000024420,100224204323201,102021301441201,103103144000200,101003131002404,100024040122220], + 110221001211044: [110201400400024,112002242001002,102112220202010,102214104010210,110042042120021,112010120231202,101011101032340,101013411000000,102100001400004,102310111000301], + 300020114102200: [103043210122022,110032020020001,110203300000121,110011244200121,101011241140401,110213440401023,101230034200024,102012001321001,100400302200312,100104221000433], + 1402201110310012: [101041301000320,100210104322421,102401001110000,100022340021012,102002001133122,100204011000221,100040020103014,100000201032240,110240010100402,102100220230201], + 303240400001141: [102003214013022,103342021400021,100102004300104,114212100023341,103004011400313,102010221443000,102300021103201,100010411023243,100124200020033,100033300410212], + 1120132242032222: [100020310412200,111014124400030,110000200110230,101021344000412,101100101111040,111102200011210,110240312020042,100111424230014,111222400002132,101003011030002], + 1000322100010040: [110200400000020,100324140141402,110203131211112,110021100023210,110000112100402,100002204340200,114103412201420,110000410001034,111140000000000,103102224034002], + 122042200102340: [114112124140000,100100220423210,110044220021000,100231020112302,110122400401032,114310000004320,102440020200020,102001020222140,103122411441211,114102004002022], + 111421010244441: [110002320424340,102031100200300,114010024010210,101040004010012,102023032000000,103000204003200,110020402004210,112300020200242,102120124004021,100021044343014], + 1403410211104240: [102102031320011,100041140201301,103021004022022,102140041342420,102140021410400,103011100120201,100000120202410,102300004110122,102202334040220,101001100320224], + 1020213431200213: [114000222211300,112023102003010,102130040230200,102000002041020,100320021000000,103013024041024,114021010022202,114030034013200,102303214031001,100001010101032], + 1214231104032203: [100012110101000,110401410402040,100020211001002,112012000223204,102311330240430,110011222202100,100201424220320,100002104103221,100010024302421,100200204102022], + 243313130032000: [101021134011012,110332202020000,104120130021200,112421004012141,102011104010201,111100220022101,100021104201130,102224410201003,110030021010001,110030410040101], + 1002010010013212: [111121100010021,110310034424102,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241], + 102232040101202: [112210010201431,103100024002220,103303000112122,112004012000011,114003100020203,100320104321221,104210021140401,100112101024230,102042030211303,101000400301224], + 1002211034233112: [114101404004011,100004414100021,102101101140040,102000021444112,103100214001400,102121001343030,112410212020002,102132210233141,101012224211030,102102002004104], + 1420024300031410: [110241142024233,101001421031220,112300421134001,112220322030220,110210301200101,102033124000111,111000034110311,103021004014220,102200001002100,100014100124121], + 1023403020240010: [100024210002210,100000020121140,103000200111020,110241020002103,102023021100010,101424100304000,100010304340120,110020010120340,114004000022042,103003444010014], + 100123012000102: [103000200111020,100100100412204,101424100304000,114004000022042,103003444010014,102002121104344,100322124212214,103121120114230,100012241220110,101034340314102], + 100021400032130: [101110044200100,110414300030001,111202012222402,102001301120112,102040041320010,103203401400132,103142111441040,114142044120310,110220410000040,100012000022003], + 101010003000020: [102000004010002,110400242014340,110000034210002,100101404302312,103020210102422,100012034201041,112431004011111,100200120302214,114202104110042,101040044003014], + 1420103002032434: [102100201440001,110400011311001,103300120141130,102110004000221,111144202220301,114224204100310,101434031010012,102304011004310,103101410212231,102100144001112], + 1130220001400230: [100042304102210,112202000411103,101040100302002,100013030100002,100310034310200,114003022300020,110124041140000,100010044101002,102111210230204,100111421040321], + 1001201111101110: [102022000210010,111201240001232,100020301020413,110421202220142,100204314320400,104121410021020,100220004311122,101230130041001,101042034041342,110404034223424], + 1122002030302200: [110000001324024,101020000300112,103100314001030,101020111001331,100002020410020,101000001111200,114010040023411,102300404024300,102110001342011,111120214102000], + 101134001344323: [100020244100302,100002200412020,100102000423142,102000301100100,114410012310230,101320310311403,102024011413201,102122421340210,114001042203020,102010100203212], + 322032241412310: [102301004011202,102000201100400,102031211121031,110034120023130,100110010410230,112121040200102,103000101240211,110022400001341,102301414024204,100134044003303], + 144043021400012: [102101204000010,114230230000123,104121001242101,100014110201012,102200310201220,110300014422013,110020404412324,110040110420020,114444304140203,103100000100134], + 130343401020033: [100223214121011,112024121130304,110004022000404,103020210101200,110010012102144,100413124100101,101020200301303,112000111120040,100402300022230,112203414012111], + 104002321020022: [102010021131043], + 122033311022040: [101100120330110,100000000014401,112212220223012,110243320110010,102100030222104,100102000002202,112012124000040,102032120223210,100000000001340,114000404011040], + 124004232010012: [101042014003022,1300001101120141,110020000010044,110111044402003,1200023010410200,1112010004112414,111043124112002,110021011310043,112032041113001,1010030200302021], + 1024030130141101: [114311204002010,110004221040341,103200204031212,102313114114000,114004102201202,100000101001431,101010014001032,102340140222011,101412020301000,101043024000300], + 122041103100242: [112132400200233,101032041032203,100021304310000,100400022201011,114212040212001,101223021024002,112400204042130,102112044000344,100302200420024,103030421244130], + 1120031002110024: [110001332120300,102101211411000,110003000420200,110243234240200,110004014411012,114110200212210,112000120232022,102041220200010,100002320113100,112240200202201], + 300303032042333: [103111001422000,111244302220204,100042100102211,100300041001121,102110030200120,101114000332010,112112211102024,114001032300011,100142044103021,101100010012423], + 1104033032101002: [112004202302034,103300004021200,102122214131011,100023031000024,103230134011412,102311011000200,102021021101204,100231020102202,102122032000420,103014004012401], + 222004402041021: [112004001122300,101301124222004,114010204101202,100041234101100,112204220200011,100230040410200,103210004031201,111231012242301,114114100214000,101104320012044], + 100013220410202: [112232002034010,132002014101100,114002300020212,102112322004011,110324012020120,101022011002422,104122404043221,114002220042002,114422012324204,103342221403240], + 212124202201001: [100003121032014,103222004002001,100003421042112,114240004110231,102024021130010,101244001000204,100030024102010,112012010230002], + 1144100011030000: [112032040234431,101020004000000,101004310324302,100120040400011,100214044220201,100124021201021,100200044121414,100200111001432,101240404044020,100133001204314], + 110301030033042: [110220301202400,110210024220020,100401424300314,103101001422002,100040120000031,102002104011244,114200142324000,102100041413022,111140122114101,100012000101100], + 133200224411100: [110000204210130,100001130001003,103102104000031,110201134243240,100100100422103,110020134410001,111100044100001,102204004042041,102101002004300,102012014000133], + 1003001020044132: [111120002211010,102023120241131,104103101240204,110020110400102,110110414402000,114220200214400,102331024110432,101100001100404,101014024010031,102010001104000], + 1022000222203201: [103120031442112,100021001020000,100004121002021,111120022212034,100001244311023,100003000000440,102221021000100,112000042000013,110010002103002,100241214020120], + 1414221100113001: [103230004000142,102011114000042,114110024003013,114142102344042,114114040001042,100000030003111,103002004001434,114200000001000,114031122210003,110000242003130], + 1014412210100000: [100310014310311,100400000031312,103230004000142,100400010013000,102011114000042,114110024003013,114142102344042,114114040001042,100000030003111,103002004001434], + 1024200410304000: [114031102200100,110003010010401,102330030243120,102100100210033,234131201024402,100002200014412,100000240122202,110040311213342,110010102234002,102003144000043], + 1402021002012002: [110102224201130,103301201402204,102401121113302,100021020124002,111201210000103,102104131412412,114020312300021,101320040302031,102400204043012,114010102300010], + 122042320003241: [110020402002000,102042221101230,101033124000402,103310421404111,103000020120303,100123000422310,100112044024030,114100042311200,102201100240444,100103100414402], + 1140012423030130: [102214011111041,100002401040201,100212304243333,102300220241031,102302424110100,110000014211000,100121210402002,102312200240012,102212004030221,111120014400422], + 1422001011004402: [102110202001010,102100020211003,100043200102020,103332044032320,111222000012010,102101220231020,103321204022210,100000004100411,114022344022303,102302434113010], + 1122030210010210: [100400000020210,114011300040140,110240032042222,110200022124020,102031001103304,100024110002203,100020134102010,112100222013224,111400204442102,110010102130001], + 132000024114234: [100002230102232,112140422012414,114110012310040,101000200310040,402023203200200,422202004012314,1004020103113032,111000000001024,1320021222410120,110230020421020], + 100210001413201: [100104341010424,103142210104020,112203001103411,100212024121000,100001001033200,100010001032200,100221110101420,102441030231300,100003220100000,114121024121404], + 110010232003040: [111320012221132,102302144110440,100002320411400,114021002331014,100041004200042,100032024202240,102144002001240,102020224000000,101242101020042,102103021340120], + 100010010010300: [110202012100020,102303010241010,111342020011220,100314114322101,102230130203001,102021401324232,111222102243400,101004410311232,101201034010420,111220410010144], + 200110030001204: [114010034012014,103200031411100,100010004300024,110122400401032,114310000004320,100000324340102,114443200000122,102440020200020,114444124143021,114131032312020], + 1430122020302442: [111000024110140,102230100201001,110000401221440,102410104040240,100020004210021,100003401002021,100001040020122,110104101220110,110112211000311,100000411002140], + 102411221020002: [104100111240003,100010101020412,102203101113311,102100200221304,101011024001101,110142010120100,100103024102040,100122101040003,102100001341200,101421011104010], + 100240334240044: [112000431120410,100031034311401,102304104110001,102000200200301,100104211044110,110200101200402,114241222321321,114013124030022,114104200220022,100021221021201], + 1101433000021100: [101041301000320,100210104322421,110100001200142,100020001224324,100022340021012,110240010100402,100000021020414,102100220230201,102203041122004,102043024002020], + 1010203120443101: [101001044012300,100112231020002,102023200221200,102240220230204], + 1420020300020000: [103232004020011,100410300433104,102303214113000,102221130201324,101020130321310], + 103044202432100: [112133102012033,110202041102300,102142120202202], + 1040032000002410: [100321004011041,110002342100014,111101042244210,110124002040002,103110314000100,100000001224221,110023410122402,114302200014241,111204200002001,100002300411002], + 1000342000030110: [100220100110400,102403004042342,101024001034211,111122004101222,114020040013100,114001012300002,114000222213021,114102330210021,100000020401302,102103214000210], + 100222040400444: [111000010041300,112000002003301,100200221000243,102400044023410,110423034242000,111204000003031,100012004110024,102142000210040,102144241343120,110411422022030], + 210200010400010: [101021102402231,101001100302312], + 1013120130223202: [100030231000344,112311011101001,110100124402042,102120404134413,101100200330040,101003201002421,110040212000010,100100221040404,110211202030440,114440012312003], + 222310134112122: [110212012114431,110202204430020,114002020044120,100021004302202,102103320232241,114102010220042,102021301441201,110000202100340,110201124211431,104103102103201], + 1101112002114001: [102101320220430,110100010000102,111312000000403,110101001304100,102320014112013,102312010211010,100111120012323,100014044200222,101001000321032,100023100104410], + 1031201131004202: [100400414321103,110302030412400,102132204131302,110020034203040,101420300301103,101010231112144,111000100003022,100113020400211,100022030414220,101210021032304], + 110321100102101: [114110202312240,112201230410110,101000321001401,100001404130013,110202022120313,114100214120211,112132301100120,110201240003232,112122000202103,102421414021014], + 101423010000213: [102400100230000,101100300302102,114120420223002,102302020212101,100030004104210,103030201434002,110232110004010,103021201430000,101002320322420,102220021110200], + 1100402002222000: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 100022012023013: [102342214020012,100120221224010,112143020203014,103001300121022,102202100204301,102411200203000,114100400000241,111300004130403,110100000120100,111010002200020], + 1104024211002303: [112230122030224,100110130000123,102030000221134,100210304340400,102201032021231,100010020003310,101042204010110,111200332222140,111201314412204,102000200204141], + 112131303004122: [100422314300200,101403014020203,111311120014011,100123011004113,100420001002101,101134224001001,102321234111310,101004010323441,102000024000002,111122222240232], + 1021200024202410: [110011414240022,112004202302034,102100104000040,100010044300003,114130210231020,112120224040040,103301410110110,112114324040000,102124031023100,100204104320231], + 111120042002312: [100104341010424,100004004102410,101104001101000,103142210104020,114400240003003,112203001103411,101022001002030,102100200211012,101224020301202,114000212331142], + 1142344121012040: [100100021043102,100010141222300,114302004001202,100100000011011,101240311010402,110020001210223,112131000201420,110230032120002,103010100110112,111014030043044], + 1121040011142132: [101220014012231,114422004110130,112210132031001,114021114023402,100210004343102,103422430124013,101000140310132,100001311234020,114242312322020,102021221120401], + 1020301140222010: [103220120212134,114200014001032,100344101004202,101040004222021,100001214210212,102020201413321,102112100224122,110041200410002,114314024030222,100023020410230], + 102220031033001: [102314220240000,110231040000334,114210034112304,100014201221340,100004000004212,110213022123233,110313204431110,100230104321104,110211042120021,100042100003232], + 1110123401200203: [100041000411231,102140040210040,114110030002020,102010031444104,114103200002100,102410010201202,102202244040132,103303001400240,102442004024220,101224231020422], + 1102132032002100: [110212022124220,100003100410042,100222034340301,101440044041401,111210012243010,102130124000000,102010421413322,102114020210302,110240301111040,102113131343200], + 1012100200222121: [100010014100021,110403241001010,100101334233020,103120110111300,103202420103102,103004330103000,102002424001223], + 120211230201140: [100120001044242,102133311142032,114221124000010,110000104200031,111034114110001,113140302201200,114012020010302,110130222010001,103000101411020,114321442301040], + 1020201011020001: [100012320001320,102000331120104,100232214222204,100040324331403,112104212010101,100001104201201,102300221002020,100002101020010,112010202000202,102033024010010], + 122221101003012: [110310422104304,110010010001022,103100214000113,100002421021214,114300212300001,100223234100201,102020411100001,101130034000022,100120004230130,114000214011014], + 1440230020230323: [102030000223410,111101312240400,100231124320130,114000010012243,100301314313133,101332011001000,103310401401023,101300130344001,114031020030012,102122024020030], + 113013042013024: [100441204302021,100011320001003,100000221020200,100200000030010,100200010431000,100003421040000,101332004231001,103300004030100,101111100022114,110210010004301], + 222010301434313: [103034031400131,114002114012041,103322000112244,111123412214002,114200220003001,100043121024120,100001011022100,100240110002411,103410000104330,100104104302020], + 1201110020024112: [100000410103200,100001240410410,101042201000011,102030001412241,101001204010220,100004301023143,114223200221140,101012400304201,100031044300340,112004021121002], + 120021102312000: [112000042030034,111200002221022,120201012121032,103200021401030,230222010240012,112102121020220,130300100333301,100020120024010,100202400002411,101002100301011], + 120102001000112: [111304340002030,110102000401214,100100111044040,103140014002031,102024102020000,102224241110003,112003020220120,100043024210301,102014001130100,114022100010000], + 1011230100343010: [114020000030002,114031000022030,100201211003004,102014002000401,103103241421322,114121012340044,102000400240203,102104304023201,103310300140324,100002224244002], + 1122201201023130: [111101034100200,111131304104201,114003410040220,114021004101032,101024200342211,110332124420001,111010332204141,100000204310000,114104200000400,100011000410042], + 211200224203241: [101001400301113,103101024004200,103024000103302,103300021402104,102102024000001,102202004011044,101012044004042,102020304000321,100021201020001,100112240020023], + 1141200403200024: [102302144110440,111130224102101,114201000004122,100143034304100,102201024041200,101223301020130,100041004200042,102322020212020,102144002001240,114002134022331], + 1013120020120421: [101020000323002,101041204000012,112112014020004,110000330024022,100221020410001,114314004030042,114311114034111,112042001120122,100111001020220,110321132002134], + 300010410000000: [103000011402201,110301232000100,100000244300040,114004310024404,110210134244100,102102032001300,102121041441000,111430412213000,114102022200000,110233010002020], + 100130043300011: [114042304100001,101211240301300,102210224012020,114313302321311,102212300202110,112101020200032,112002002030004,100024414212001,114203134112000,102000000221441], + 214021300010204: [110022004410312,110400011243102,114100120223101,102000401442010,111020004400234,321114010100340,100121041041101,102322101000200,101020041000102,1042012320010021], + 1110401002041240: [101021014002020,100443210030204,112130004043234,100220304100400,102102004000001,102400121110000,100024204204210,110013032003011,101240104011041,110000031021411], + 1102230420104200: [103132001440132,100021231022220,111220244103011,112412000201003,114031442303000,101003401032000,114310324001300,100000120100310,100312104100112,101201301012401], + 110131133221013: [100020201020032,103002221400000,103001010101001,111020142144200,101000231002001,101000211031021,102020001021010,111300022201241,101313201003110,110020001210102], + 121113311220421: [110400000002213,101031104002100,114132100210100], + 1040142200301340: [114000302331201,110021022103102], + 202400402100130: [1342140400001210,1203210010100211,400114001102410,111011220004001,431232000323104,100221110031000,1040100003200241], + 1110030011122340: [110033000022043,104412212102010,100432200033101,101230004040022,101021020324310,103140021211010,110132020031210,100020140121034,102340211000200,114420230000240], + 1002012421414222: [100111011011011,100030040101021,114310102300021,102400124020001,100102224234101,102010321411140,102111131410342,100031120413224,101304004220404,114104214003030], + 122034000041214: [103201411402002,110022000023010,114020302300110,111002100021022,102302120210122,114100032320203,100400300013000,112041210224114,101012000320441,114124414000000], + 100042021311022: [102231130213210,114113104123200,100023024211011,101210210300031,110002021121023,102300040221403,102201100200430,100114021040000,114121300224141,102301100241002], + 100314002002312: [110202012100020,110013202003320,101031241000010,102303010241010,102120231343224,111342020011220,110030332100203,100314114322101,114404232310120,103100034001310], + 1101000011321130: [101021134011012,110332202020000,104120130021200,112421004012141,102011104010201,111100220022101,100021104201130,102224410201003,110030410040101,101300401002320], + 1002334323010000: [110202012100020,102303010241010,102120231343224,111342020011220,100314114322101,102230130203001,103100034001310,102021401324232,111222102243400,101004410311232], + 1020120110201301: [112413224040101,100220100110400,101200031020230,101024001034211,114001012300002,102121100232012,114102330210021,102140320310003,111001100020413,112203101100310], + 1144002300012000: [112213000200301,100003224334120,100404224300012,110204130004030,110202120003032,100322004314021,102022010220223,100404000020012,102343301100440,102410434000220], + 130044301014200: [111102420023101,102102244000330,102001004012322,100004001041301,102222131120032,100203101000022,110021130004103,101000021021110,101000000320000,100014011024000], + 102010240442002: [100003204214320,110040331214411,102012120213222,110011042200200,101014214010014,110400014240224,110020120140140,101000221030024,112040024013124,103302200144000], + 1000320022202241: [110202004211120,110341010044330,102031144010424,111021030042411,100302420120212,111212114131222,102140001441301,111012030022123,110031424214112,100001230120013], + 114000410030404: [100023114341301,111000020010011,110101302141002,101000101000440,110114102004120,103212121402022,103330410111310,110201001200101,100102014001304,102022000202001], + 322122213234114: [114003100030002,100110221221202,100122004230101,110042240021022,102101441123100,102032341100040,111004002230102,103012024012300,103030020110002,102234031103000], + 112231010320133: [100142104100403,103222004002001,102024021130010,103200224020100,103013024002104,112012010230002], + 100231001000204: [110220100000102,114042102330002,102102011414242,100041004100221,100014001041000,102310030240210,110000010033022,102210000201040,110110122210000,102200400234000], + 110000010300102: [103212014020132,102102030214401,102021420233130,111130410020021,101022000302211,101232020300432,101132000302333,114020024010021,100044004210004,114020204024101], + 240003001014401: [112413224040101,100220100110400,101200031020230,102403004042342,101024001034211,111122004101222,114001012300002,102121100232012,114000222213021,114102330210021], + 1022032102241412: [100002100100320,102024401440202,103200210100110,103220301400000,100023014340130,102124231401212,114202024111304,111102222110021,100210000430203,110200102020212], + 1012021310200010: [102010040210212,111120432100010,102012201103000,113223002430413,140230300211231,103010140000114,111113002242010,103122200123301,114021034100241,114231004000010], + 223224002000100: [401000241000000,113330300000122,404402020103300,112140004002100,100120034020032], + 120000022033114: [101200400041032,100001034102143,103001224014142,101201000311021,110110211200222,100104200411203,111112034400031,102042031440222,101012021030223,102304000241010], + 1140002213020001: [100231114320100,100001000002210,100400320033201,110011402100202,101210300302302,110121112010004,102020131413423,100000220011133,114013012240011,100010104312120], + 1010211412010211: [103104320211111,102000101120401,101031001010041,100300021202011,110400314221140,211111010203024,100020324210410,101400100300002,1040001441000231,100122401224222], + 1000322321013021: [100003121032014,103222004002001,100003421042112,114240004110231,102024021130010,100030024102010,112012010230002], + 100321420022020: [102113101341130,103202130130000,101222121020022,112431024044114,103134314000113,100130014030430,112300221134030,100000004230023,112024204000314,103010044002100], + 1002220201011202: [103000104004220,101002244004011,101442024042013,101010340331320,111000024410303,103031100142002,100241131003241,100201401010000,110000040420100,101100424003101], + 1214220004140230: [103000004012003,112303041103203,102020231440400,102144200210031,114030304122412,102121104130242,100112011040312,101013200321014,111000220020441,102102011400201], + 1020323442100401: [100111011011011,100030040101021,114310102300021,102400124020001,100102224234101,102010321411140,102111131410342,100031120413224,101304004220404,114104214003030], + 1002000144000023: [114001000020102,101020040300010,100213001000212,100040201012040,100002004212420,102121014002022,100141404233000,114100222310230,114131002342130,110002022003101], + 1000210320000044: [114201232330041,142321203003111,103200344020420,401210002011000,404010201000410,1014200301032410,1103013112041021,102030001201100,110200024240110,110431004224201], + 120001112030000: [100004221034100,100200200412034,101012114000304,102232024002401,101102120301114,102202141120400,103400014000012,110120224221100,110000041322002,103444024001001], + 1121010201212010: [101040130301020,110044100443224,100000101223200,100402322200000,102211400212122,111404204423311,111132404421001,100114110003220,101203040300402,112400414021201], + 143100243214031: [114404010003320,100013200412401,114030412303102,102200320200003,100430000030122,114300104032040,103201101402422,101040004210301,100100101040120,100014011034001], + 1003020004044110: [102430231400211,110112012140003,112110220202020,102004021102101,112002012030102,112020021110112,102302004020001,112120302010202,100020010000104,112120020220421], + 101112300222332: [110021220021121,100002120412400,103322424033024,100010130140100,102103201412111,100001214302342,102233204000002,112011011132021,101030240322011,112312011103030], + 130001301114222: [112324002020202,100120221021011,111242212222022,102022411100012,100020100100300,101401140300101,101242000300000,100030124210101,103220200100320,101030004004303], + 112000420112230: [110020301220324,100041000010302,102020100243032,100031001020040,101110404021211,114210400000112,114042014102321,102112222001200,100021104100310,111321314133000], + 100001010030400: [110030230041304,100043200201202,110102110122210,100140001040042,102111214004020,103212144000440,101422120334233,114243122320133,112023001130021,101000301004122], + 1220300111022300: [102102000213403,100140000410014,101041344000400,100020420123031,102412020234414,102202424111200,101002424214013,100012101022110,100400222200110,114011112202020], + 224001302002012: [110000322130121,101023001002020,111300222202234,100200001210021,103204230111030,100422211004214,102100000210002,104130020011020,101114422122000,102001314013400], + 1141414000020410: [101200030300000,103010304002201,100410001010411], + 1143030222112134: [114113344123222,112242202031200,112144012011101,111410302212101,100013104300114], + 103200312402020: [102331021100100,103223014033210,110011202100142,102123411402002,101042201030422,100410100030221,100002001211230,114410102321111,114012002212100,114203110001031], + 1003000211211212: [110024404201041,103014224004000], + 1012100440240201: [111121100010021,110310034424102,114400202314210,103022110142241,102101211410144,100024201030210,102010111102410,101000110322242,110100001014311,102404110230202], + 1042100000041030: [102001404012100,102340120222440,102122214131011,114223204100010,111041202200140,111300400002313,111101040014040,100023014313010,114021040010311,100020004101012], + 1000020100003001: [114022300022421,114401200000003,100241001003002,111310004122000,101221000312044,100400240013333,102030300224002,111001314111000,103100040210040,100210001002200], + 130301214001303: [100321004011041,110002342100014,111110200020323,103110314000100,100000001224221,110023410122402,100032134341034,114203104001000,114302200014241,111013102200342], + 221222030204220: [102103001411402,111030244400003,114020012300033,112110010202002,102011220220120,110202004242011,101032121112212,102210014033004,114000020032222,101241200304401], + 1003414034014211: [102000001410411,100022404242424,102111021341042,114102210002021,102013300200042,102004030201320,101432221011020,102240022004402,100020310101012,102113301342231], + 121040403014300: [102020000204032,110000000003200,111401200000040,111202004100121,103230104003200,101041204222101,100024024211001,114031000012100,102110001342114,100222220001202], + 1042212020201342: [111121100010021,110310034424102,100100010422000,102101211410144,100024201030210,102010111102410,101000110322242,110100001014311,102404110230202,110043400012000], + 1002043000111221: [110024010440102,100033410104422,101012040320004,102100410211031,110142322000202,100100444300402,102021214001120,114011204102241,100023311224032,100000104310040], + 1401033001042023: [100242141004122,102024240221040,100004004102002,100011114300334,112020201120340,102303004110022,100110201042101,110134201140010,112101044000202,100040024340013], + 1404044002301014: [103221400100121,104101010010200,101104234001200,114103100220201,114002014101011,100004202211303,100321000110200,110021110043033,100011014302010,110241101310132], + 1013001000022111: [102132400232131,100114234102203,114001232300102,114023224010002,102323324112410,114400112311040,100422140030210,103000041402003,100010104210010,102000141133020], + 1000021040102102: [111101010010203,110110212010011,103120101441202,110011000022102,101002121003112,100004104210221,102202410240103,400014404414011,100000010101402,102010414013103], + 142030010033000: [100030024303023,110303401230040,110012000141104,140300020110000,102001021132022,100003301030120,103044004034040,101020230301220,102210241120001,102412140201410], + 200242400033020: [112224202021421,112423034041001,111210122203100,112040411110201,111123014400021,112000121132000,103120300211022,114142144124302,100002001020040,101031402400002], + 321330122010041: [100430021001320,204020131034103,103214301421201,1000001214032041,102100204001030,100102240020100,102210000240404,114320124031023,114220020213314,103141111442241], + 300010212004000: [100203321001221,112111040230130,103010041241404,110333010011034,110423301004320,101110140302324,110401321340320,100004141034320,100220200430102,101010104002400], + 1000142104014030: [102100420231433,103114001444241,100020214240402,111324002200000,102013110232000,110014032200004,100001214214401,1113004122042140,114201400000103,103110204004240], + 131331401002014: [102000020223013,102110201342300,114300204032002,112121032014014,102310111001210,100020241043022,102100121341102,102001231444003,114100304142330,102333014110114], + 1011001211030222: [114200212322001,100401210020002,110001440041003,100010111022102,100220300410430,101024201114010,102412220200003,110012222000144,100201214123301,114302122323101], + 230000220330420: [111004302114011,100010410101220,114400012310301,102004201410402,101201440002012,102040031411210,102014004000221,102002240210000,112020210233321,133001230020010], + 100024421010021: [101421214042002,111430442210202,103420144004301,100002231231033,101101244201222,103304110111122,102103114022230,101424240300300,101130021101100,111042002202240], + 110012023000010: [100034100023401,100320221002000,114203022320020,110140042002031,100140214101212,110120021300003,102220202001002,111200104424220,110141041304241,110012000002021], + 1020114123004020: [110020402002000,102042221101230,103310421404111,102101134004010,103000020120303,100112044024030,103240100102101,114100042311200,101010001000400,102201100240444], + 114032420000111: [102000201131020,1010120030012200,102123332000002,100020140120213,114020012211102,102020034002300,100000104302202,112412000201400,100032204312024,102001114000000], + 1141010133004121: [114042032210200,114404220000142,101100214003002,102410420230111,100004121032030,100404342201400,114440210000102,100030211200100,100000120412021,100030101041442], + 1032143310002000: [111104102242110,100002200410230,102110201342300,100044010200300,102000021444112,100003010413400,103334120114003,100130204300200,114032124013234,110112131124012], + 133103224230102: [101204334232020,112012002303014,100004340004131,100210421004302,100200411000410,102003101130231,102240200214023,111021220021002,100101200410420,102101024002102], + 122410022210000: [101221422120021,103001024002110,100231114320100,100001000002210,100400320033201,110011402100202,100004130002301,101210300302302,110100012120201,102020131413423], + 1011000200000200: [110141010001110,104122011242020,110213401202210,111103310001234,102312000240002,102012104010301,100004004303030,102001424000000,100011011232320,110011200010103], + 1113013032201011: [101300000310241,110002010002100,110001302002012,100010204103214,114104120220001,112014312310014,102004311130001,101214301020044,112004140233122,100003020003040], + 1130201301041132: [111304340002030,110102000401214,100100111044040,103140014002031,102024102020000,102224241110003,112003020220120,100043024210301,102014001130100,114022100010000], + 1021000000430123: [110014002132100,104122202100000,102200210200442,103100304000131,110011212102422,100030100104111,100312021000201,102004010202104,100400220002400,114100024120001], + 1103000200420000: [114200402332011,100020101031131,102101001342004,102142221401140,114004222211104,102114204020220,101201020300003,103012201401210,101211111020000,102442100201100], + 303312302243004: [112111104020400], + 114001040100020: [101230040301234,102104231340013,110033032100000,110011002100114,100400432200321,103303041402240,102331010240100,100020200012311,114023102300012,114140144122230], + 300100010031104: [100000210410212,100202021212012,102000032003002,104003410010031,100100000012334,110020030011011,103020201401104], + 143210140020003: [101212114014000,100043124212321,111103004400024,110003032002202,101403011112301,101141301110112,100010314310021,101111211112300,114130224000034,100034131030102], + 1010221200010002: [110441140102024,101004120224442,100413311002132,100320421001431,110210301200101,111131102210013,110400241240242,101001024210000,102210101121104,110023102103200], + 114201010100014: [114300402301101,103020304000320,100100104300012], + 1022002042012111: [100100121041013,101401211012010,114000010041320,114120204003101,101020230322012,101124031100013,112004302030010,102100001400332,111100124100113,102410234040000], + 1004441004020034: [110233012120121,100000241030333,100020011020010,101000204002210,110112210000002,111002042204201,100001204130442,102100321410122,114024004020023,1014400221004004], + 1004220001134022: [103201411402002,110022000023010,112000124022430,114020302300110,111002100021022,102302120210122,114100032320203,100400300013000,112041210224114,101012000320441], + 1040310103220120: [101020000320011,110400014223001,102040404010111,112040222311040,100100101011200,102204404111433,100420320030100,114040214101433,100312121000310,101022220322100], + 131301024004202: [110200002031302,102002020243020,102040021121030,100000204130001,102041130200101,100412441010422,101010200312020,101040204210210,102300310220121,110000324412304], + 120000042402110: [103011200100000,100111011040002,111020400040100,100302000140222,102122340200200,114000214021240,101311111000100,100040341021101,111123212212000,102400220203010], + 1001022101024120: [100001220400300,102212001103340,100002334202400,101222401020120,114010202211102,100023004304344,110220242131013,102102010214104,110211030000131,102222312020011], + 100004120201310: [101041310301004,101000200340220,110021122100000,110000000143124,110100042013221,102121304003112,114431224113420,114033012202420,111211002241330,102420001400320], + 1240203003021100: [102001201440040,100212000030034,102300001100112,100121010400103,100121111001223,110201030101402,114431000001000,110040401300010,111311244120030,110022010034100], + 1104211101100020: [102242320200020,110030021222310,114010104030002,102010011011210,101041020321002,102013131134030,103312010110013,102004004010011,114101042313041,122112024242100], + 1020200410222000: [104100002100221,102000321102310,112000044002102,102134044134410,101202001022000,111300220000230,114110032343001,100110101040020,114012222301110,431300131230002], + 102001004014022: [114111140220220,112000204001011,114004100011010,114302010000013,100100124003241,100002310120001,110220022111241,100022024100312,100204001000301,101001134210404], + 100000200041112: [111100424100021,110111121011004,103001020104102,100002214210110,111001002201034,112024144002202,114212434100312,100013010001120,102200101123440,110302201334022], + 1001124200300113: [101133001104410,114202424001100,114113004120221,1100000411441420,1002203010011112,101211011012300,100010300121240,1012004033012200,402001100011120,100020321030202], + 222013004140110: [100113220020101,114031000022030,102014002000401,103103241421322,100300211000020,102104304023201,100002224244002,114310200002400,103211220100010,101202201021310], + 1104003203100220: [110021104200001,100302141003012,100000301221024,114100200002120,110310020040401,110200010014000,110202204430020,104120221240413,100002024303323,110310002221402], + 1420304010034240: [111121210031101,100013100100014,100000001020000,102000404002002,100120234300003,100121331044301,102100014000422,100101010100200,100031011042040,101403014021204], + 1022002220020032: [101130200003423,110002121200000,110300412020442,100000000001140], + 212002430430101: [102121221343020,112104424022201,1302314034023041,1001010233020100,112012200120020,111041134000211,1124042220104011,133010044232231,110000400001130,103201021200030], + 122030001322004: [100301224310100,103002104012101,114021000012031,100012324202240,110003410100312,122000430101030,114000022300301,100311000141022,114000000021100,114210202322020], + 1011014042130011: [110001022000001,110023342101220,110002012000400,110020422131120,100001000100000,110202222043022,110313312021120,102223400201104,100220214333200,110330234422000], + 1432031240003440: [100020201020032,101410211021400,100004214100234,103000011400001,102104241412223,101400200303132,103001010101001,110220000113011,103100000210002,111030014120004], + 310412123100110: [110301442021010,110001332103022,112041000220020,111304202202230,111300000001323,110000002001040,100440441010002,110040310040200,104020020001030,114003004100001], + 1024120321201003: [112000112000031,100142104100403,102123214020000,114202204113222,102022124012030,100143220410040,112024000213011,100103030001121,111000004400110], + 1001002001400001: [114132202312102,100021110200330,110322110010000,103214104034020,100400000013010,102142020212132,110222201200000,110302400012002,100103004000123,101230234011000], + 1201030211402330: [114030110041300,102300001002144,103001000142003,103132424000410,112013102004422,100400220013232,110010002000100], + 1000022110011002: [111102004100101,103122020213112,102140014001101,102000104012232,102021100220101,114000040010421,112042110220004,100000214240410,100433201004014,114122134140002], + 1003001200211022: [100020004313034,101400120320033,110430030000041,102140411342420,103243024040441,110021014412440,102020004000301,114114204001401,101042214000121,102000121102220], + 1021100244301333: [103110411420200,1344004001200102,100110034102102,1300011101120023,203001440023021,111131400032010,203343130112210,100402202200024,1300001321030230,112223432021101], + 1022232402221001: [102402024000034,103012024004312,102214020242110,114102224104002,114422404110312,101140320330114,101010010300020,102403144000120,112120020230024,100000204100304], + 100321434112020: [110102042010220,101020124000413,111210000001101,114013400011030,103004104010210,101220024041000,102010300201414,100202200003011,101413004041201,102334000243030], + 1104000032141013: [110301442021010,110001332103022,100104004300024,112041000220020,111304202202230,110000002001040,100440441010002,110040310040200,100430440030020,100100124301211], + 1211000030020040: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 1031120104241002: [102202204040010,103333040110114,101022200343023,102000000221222,102011014001111,102331201001140,102101001342004,102103001414002,102022011101012,103002014010030], + 224210042002020: [114301120000030,112004000214201,102221002020200,100020224101141,100232034333120,102001101132230,100010320201332,110004224210020,100340111000001,102302011000130], + 212301402401002: [101001131032132,110340014422102,101022400300001,102140004000100,103202130122102,100021000010213,100231004220242,112430010114123,130020100202200,120002101133400], + 224222010130400: [110220220012422,103003311430003,112201001104112,100340000142320,110040014203342,110042132003320,114121204120122,100401200033020,100222004220000,110000104410123], + 1142200300020404: [112224111100141,101221414041100,100032424312011,100210301002021,101021244012200,103040000000212,103000001410123,100100040402102,111240300002140,101300004211000], + 1001010002401400: [110104112010103,111102004100101,102202414041044,102140014001101,102000104012232,102021100220101,100230120001003,114000040010421,112042110220004,112203221102231], + 1110100120011221: [101003201002421,102034004000133,100102240002022,102113000210043,101010011034220,100421111011000,111232024102030,111020034403330,110001212034012,114020004022002], + 1001301100002011: [110201201211024,110202000000310,100422314300200,102141410230020,110020001224021,101110020013040,101012410301010,103120001400003,110003302000101,111122222240232], + 201000040000103: [104130242103012,110100221223104,102000101132400,102412101112121,112023140212112,102110244000130,114000312301300,100102304302000,102400231404200,111113022242200], + 142120402221003: [101223214040000,100304031003410,100202100012203,110130001001030,100022030420202,100403300010004,100402420012143,103000304001231,101014010320000,100200001000020], + 1000201021430222: [102242201000222,103000004011102,101000011032120,100120041014034,102102042002001,102110444130000,102130300200301,102111001341321,101104220322100,112434010204100], + 1040332000033142: [102102011342302,101030224004130,112400024011003,102012141440022,114000010031201,114204000003310,102100301021042,114041102304310,102411021112003,102120010202004], + 220120000200011: [114101024120020,102004011440212,103140320213200,100000001021013,100011204300012,100001021221000,114003134011032,100101234330123,110024000432310,102012101443110], + 222200101424203: [100111334330000,110023240021020,100300433210004,102240100011000,100400213242110,100020201002004,120021202100230,102320120240200,100000012221111,110102301010411], + 122202223100230: [100113214302002,102412004000132,110000002133140,101233341022410,100100124100031,114100012313002,120240000020201,101004202403121,100304320140012,100002110100312], + 100310120031012: [101110000333030,120210240004122,100030134340020,110002140002200,112020241111142,114031440010031], + 122013303234113: [112302112020021,112010032340022,100002104302110,110030222130000,101022440300020,110204434434200,102110224000013,110040030001400,114020210031032,100141410402200], + 110110410002212: [102300101103002,100101101000000,110020002130012,102322200210000,110104010022000,110014044200000], + 112200223000423: [102043120223043,102020204000002,102141004001412,110111002011424,114011210043200,103241001400040,101044001000000,101120032114401,111302222204122,103200424030200], + 1100023102323131: [100020201020032,101410211021400,100004214100234,103000011400001,102104241412223,101400200303132,103001010101001,110220000113011,103100000210002,111030014120004], + 1441301013001024: [111131224100212,102010104000341,114120100223000,100404010020000,101240000302141,1204002112200213,110010302002100,102101201121000,101100001111040,110031222130200], + 121200110100010: [111124004101012,104102040011120,114103220220104,102120004001310,102430121110340,101021204000200,102020121102120,112141104020201,101200111020111,110001200422320], + 1423120000420110: [114021004032120,102102112002431,102404200230330,102323234114200,102002200244011,102201014020311,103000304013020,102402001110001,114320204034234,100210021001204], + 210002001303120: [110220100000102,102100321320100,114042102330002,102102011414242,100041004100221,102310030240210,100000000412112,110000010033022,102210000201040,110110122210000], + 1110104004200300: [110420301340222,100024000010302,101103031103004], + 103044424010103: [101200011020000,112000044002102,102230021122000,431300131230002,103042141420430,100121021011022,102214001432020,112034420220403,101211231023001,101011420323313], + 300041221240122: [110414402020021,114312012300300,101012104210042,101430001010032,112402012020000,103322241400404,103210120100143,110101010011124,100040000123130,102001341102111], + 1241000103202121: [102121221343020,101010101022202,112104424022201,100013211002142,1300034431310021,144020001004041,1001010233020100,102210104000000,112012200120020,111023100040110], + 110310010110130: [102121201340001,110400242110410,100030020423044,110104101002000,103013104002044,114211004004210,100034204310001,110011340001104,111202030012240,103012111241130], + 1034021100104140: [102010124012100,100110100410210,102000111101030,101102204023404,100440100030210,114200340003213,100002214201101,102110004001320,114202322324020,101403100301000], + 1424103010000011: [112224111100141,111102214104403,100132004231230,100000030000001,110021340020022,101010001000320,110210020104031,101003204000300,100130334030100,100210301002021], + 110241020202110: [100100201020222,100020314101112,100340121001230,100010220121201,101424120301002,100020314311220,101010221000033,102032100202020,102104010203421,101110441011200], + 1101220131004301: [112413224040101,100220100110400,101200031020230,102403004042342,101024001034211,111122004101222,114020040013100,114001012300002,102121100232012,114000222213021], + 1220100001104003: [112142301101040,101100000330120,101214440300301,101121100332142,100000400000241,111102214104403,102011004013000,111200122222334,102301024113440,100033230420102], + 1000231411023012: [101013004000130,101420031021021,112040014004212,100201000011432,101042144010200,110420010102241,102002031120120,101120134001144,101004231020140,100004100412101], + 140232200110400: [100231401213132,114210104113314,114021232300112,103001000120444,101144024000232,100000010011430,100114420000140,102022300241201,110200100001242,102100042002002], + 100222300022032: [102002014010234,100031001041013,102042004002000,110014231333243,112202400204001,100100001010102,102002014014424,114003040042312,100122014301301,100010444102042], + 102002021000014: [114021412213020,110030002000422,100032121024110,100402431012022,111403100030130,102031024013013,102402330230011,110044020020202,100001140000010,102324410243220], + 220003100020230: [110000204210130,100001130001003,103102104000031,110201134243240,100100100422103,110020134410001,111100044100001,102204004042041,110120144204004,102101002004300], + 101410222111214: [102002120203400,100002020120200,102000431130020,102143000210010,102330124110411,102303342001023,102400404003211,101300124233021,100400000010200,101000211142140], + 110121400221044: [103111010102100,110230024213001,100403312201120,102220030200111,100411221010100,100421001011020,101022401000022,100000414100213,102300011003010,110000321010110], + 202003000100023: [102400340230442,101000400320004,102101044001201,110320024422220,110003011010210,110220231211201,112411200203314,103202024023021,102101011320111,110322202104032], + 1032302044100213: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 1004210103100403: [102143124001400,100020440122040,102002034010400,102020030220401,101002121000111,112404002023002,100033134104200,114003422304142,101432024040221,111001404112102], + 122021304110111: [114443012310100,103003010101104,101022024010004,100030201042112,100410224304122,102404200230330,112313301100030,102110244000130,100013020204021,102313310224103], + 1443120203410000: [100002020413201,114330000002220,102000401130003,100110110020203,114000012300000,114040004102003,110402000001104,101400104024130,110004131231204,100002001041001], + 240042212001120: [101020414010211,103303001404000,101410021100102,100110004101000,100040020201004,102000034000000,112400200201000,102221204020110,100103121021000,112100020204342], + 131100040000022: [102400040202040,103121420214211,103222014000001,103000121400401,110000221104000,102042222021432,112404002023410,100020010124400,114200002320302,101020000343040], + 1030020114012040: [114313304002310,102004110223232,112204010411101,103202404003021,103211010211331], + 104124010221030: [110011232100412,110232002101410,110200021210212,110100100031014,102401010202301,114240000001020,102112004001032,102204114114214,102212034044212,114411120001020], + 1112010044000324: [100112021020320,114212104110100,102300124023122,100000104100102,111022134112141,102001040222000,102101004000001,100121214300000,102001201442022,111103214104101], + 1104001004000403: [110130302012020,100000211021004,102411134020204,114032200030021,102000000224012,110210120000001,101000120303020,102000001133312,100402000020413,100011044210004], + 1010000101201121: [112211122030420,101031201001231,102000010202042,102020001100001,101011014010102,102020324002022,112013012301132,102001104001214,112440104040110,111004410022000], + 340241311002113: [100001020012120,110031212000202,101441101010020,112310010200312,111202322222023,100002004342004,100000130100210,100020201030113,101033300332204,102030000202240], + 1002021221234123: [111103240020200,110022201100020,100141214304000,101430001012430,100011204100020,102410220200004,102100211340043,103443104001332,112100311104022], + 1010021122010120: [110020301220324,100041000010302,102020100243032,100031001020040,100104001041200,102012200202303,103300004021200,114210400000112,114042014102321,103230134011412], + 141404200043000: [114203042330220,102102231400111,100032421040120,101004201001232,100000400412200,100002020101023,111100232241200,100011234202334,102111024004010,103343010113030], + 220333033020012: [102342214020012,100220024324023,104130011240303,114100212210001,114143200211211,100120221224010,110402101344233,101001011001300,100112024032033,103112014030001], + 100112200011220: [110120144200000,114022412330004,101200221022044,110241112020204,100002004104004,102100104002224,102100224000210,102310140240012,100014204201000,102103321411004], + 1112200001024110: [103020031403100,102200401111200,114003104031111,102302331003300,112131004020212,102003211120021,100033001020140,103131420221204,102120141343312,114330420004101], + 1240032120324224: [110001420430300,102213210200210,100000111040212,102013003040043,102102114132212,103010424023103,101232100300211,132322214002004,104101010011320,1040412210213020], + 1140202213000312: [110013334202122,103330104030103,111200002220003,112043421121002,102212030201100,110002302101012,100111401011110,100104234230043,102010341440030,100001120100002], + 112040104103002: [103200211420103,112203242043001,103023021244000,110104434402221,114323424033100,101421210302410,100030034340432,100004001021001,110241130013040,101020204002120], + 112002004100010: [101202001024340,100004000102302,100023001042200,101030040320021,101003101000000,114104000002301,102232110201100,111203040002344,114223104002130,100410300030220], + 244211021443101: [100020100022221,102011204002010,110411031110000,110120041343100,114110014000002,100000101042100,101120004020213,114002202300120,101020004004303,110003022203202], + 130020024021432: [100000044240301,110204002123041,101140021101302,111120224100101,114440120000030,101023041001203,100201021001300,110212001204000,102010014001001,100211400140102], + 202424041100244: [100002010002230,100002214312112,111021344401134,102000420203042,102000211443214,202240120031420,100024000000132,101003021034241,110240412120010,100121014104140], + 130020200201202: [114020000030002,100201211003004,102014002000401,103103241421322,114121012340044,102000400240203,102104304023201,103310300140324,100002224244002,114310200002400], + 101044404010004: [102000401123201,100400040033043,100002004302011,102244421110032,101340020341021,100420214300311,100104004301120,102110022004222,101000421030200,100202034322202], + 1011213232122300: [100040201210010,110442111142110,100200220110004,100032034104034,114401110003222,110422120034403,102001201130140,103001144011302,114314012301300,100020131031104], + 1003023213014000: [100000241020300,110000100022040,111021030042411,110100100031014,110131011000142,102401010202301,100201134320102,110000302122001,110202012020000,114240000001020], + 100332003224332: [102104004021010,100244204311004,104132001240113,111221000010010,114302044003120,112211222041401,102000100240000,100010201023140,101024034001210,102302021000041], + 222024011001401: [110003002010123,102003010201410,100000010000211,110001410002011,100022024203420,112012121120420,111011200020400,100110224232000,110210410402132,111402202210233], + 1014432200024423: [112113214020100,102010202004402,100000130013400,111130312211003,103224041400220,100001321032243,102104244000010,101001010300404,103340004020422,102410220200004], + 101043031044413: [103211200100400,102112231020231,100022004300020,102320000240102,100042144200000,102030304001101,100020420121003,103020004011414,114201204111002,103310111402022], + 212400220001120: [102442024024214,100443211002141,101012400320022,100011014103012,100030220101040,101130031041024,102031004002014,101240021020011,103140100210304,100110000030000], + 1040010043012002: [103011431401300,100002200103104,110012101102100,103001001421100,100001000100004,102040300241403,103000310100320,102103331400000,114200022331002,103013004020003], + 1001002002401400: [103120200222330,102000421131000,114404020003022,103100114000000,100421242201010,114410212320200,112020011110100,102030000221301,103300010110424,103020011430001], + 100214400300104: [103100044030033,102103410200411,112404030200022,100031401222220,102020111100100,100041440102144,101044020301020,100024020010040,100001101033020,101024410341204], + 1012040004001014: [120402022102021,110140101300004,114400210002021,103103221421013,102010002000402,114233112330324,110423221000200,110030211224203,114201402332241,144200203310100], + 1102331100200030: [100002421031242,101212010301103,103103000121103,104000000010243,110441102112020,102020300201021,100122004323202,103040230104020,101102320003202,100011020140201], + 1400021242232400: [101033031004120], + 1100220030222121: [111020002201420,110124341203132,102000001132022,110312002100244,100000010422201,110220242120201,100030040004120,112230214002002,100033014342420,100404001011014], + 111200022022200: [110200002031302,102002020243020,102040021121030,100311314310000,100000204130001,102041130200101,100412441010422,100220031001210,101010200312020,101040204210210], + 101022440011103: [110130314400100,100104010021241,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241], + 1012112312400001: [114002014100310,100020020121132,103311100112220,102112002004120,114400004141104,102142234000020,114402044140023,111000024404021,102021231100030,112023114000210], + 200312010321031: [103002001240043,112023420232024,112002002003003,110002120000000,102340001102023,101202101000104,102100034001000,102302121101002,100400230021400,110001200421021], + 1111001400321000: [102031000211000,102202131004010,114211132343224,102020021100000,102200114011100,103014330110310,110020120040202,102241010230310,110224010010021,102441120234110], + 222002102020040: [100040201012040,100141404233000,114100222310230,114131002342130,110002022003101,101020001030204,100403122201202,102303304020122,100310210142030,114132012200110], + 1203030030432101: [100102004100201,102114020210202,101200200302210,102434211400021,100003000412141,100001300100302,111230032242001,102324031000000,103230004030322,102102001341000], + 1244020401100210: [100002104302320,101023424210024,100021244103133,112001004004000,100201440000313,103102400211002,100113040414312,103000030101020,100140114102021,114002232302004], + 134301110112000: [112302112020021,102000224000000,100002104302110,110030222130000,101022440300020,110204434434200,102110224000013,110040030001400,114020210031032,111010434400440], + 211041000201432: [110023342101220,101001421031220,112300421134001,110321031234422,102223400201104,102342120222031,111000034110311,102221010201113,103021004014220,102200001002100], + 102002120000000: [111222034100421,114222204004232,102023231101142,110000102001102], + 130111020210041: [101200341010102,102301002004242,100131011001300,110220002041102,103200030110000,100210024300001,114000444100400,100000200003102,102030031133201,110011000040030], + 1140010001220003: [1132120124402200,101200111024003,1113000131022000,120014042200110,100033000410011,1001101000204300,112110200230004,404440001010000,112031240431420,400400120100110], + 303040401010101: [110013312204132], + 1002410020300030: [114003344011001,100021101000000,102334021001211,101203001010111,100031201030102,114201104114111,100001100411302,101414214021020,114123420002142,100000001024010], + 1120314101200001: [110332102020012,102140014002141,104231322021221,103122001441103,103141214004200,114000430020024,101104301103200,114222404114003,100004004101010,101004224010112], + 112000432400200: [112004302004223,100410001002331,101400204023104,100011030420233,110421010402324,100000014100111], + 1010030010021000: [110033232104020,101201000041022,101204220301114,100002211021024,101012000300302,110100021200402,100122034300003,1020000000204104,114400034111022,103201224021013], + 1020110102110421: [110000402130200,110210002110430,103024004010134,110102204202001,100141101040123,110422420030000,420011043004003,110040002032114,100120414100102,102404224041131], + 103323200011220: [102120404134413,100100221040404,110110121300321,103321311400002,101420111013041,100000040411123,114001002211121,102202014001000,111040404111403,100123100000120], + 1043412010030000: [103000004012003,102020231440400,102144200210031,102121104130242,114104220000003,100112011040312,101013200321014,111000220020441,102102011400201,100400302201011], + 1103414011210033: [100422040021304,100002010413410,101433010300204,102114321401000,100002414201103,110324444424432,100122234300420,102001001133202,110222400001204,110001104210202], + 103010201133430: [100100021040144,114011114123044,103042141430211,100102404100430,114142044000010,102101404000000,102300200221021,114322222322000,100104020022212,114024104032203], + 102313034204010: [110432300102000,100011004102400,110040344210011,100003200020112,101000100340001,101300240310420,102100020214203,103000300124010,100030301030114,114211410004214], + 100202300110420: [100202400140300,110421220003142,114404220000142,111210302220403,101100214003002,100004121032030,114002300040001,100404342201400,103002001420012,114440210000102], + 132201202203040: [103134014000340,104103100010141,111101222240010,100040210411102,100110004102034,102040140220220,114010400014304,114300132321233,110000140032001,102033340222200], + 1111004200000302: [110104112010103,111102004100101,100122004300410,102202414041044,102140014001101,102000104012232,102021100220101,114443330001442,100230120001003,114000040010421], + 1044110410010031: [102140000212141,114301000000002,100113324103000,102424114020143,102023021321020,102114020210202,114040204014042,101200200302210,100001300100302,100040401020413], + 142110442131233: [111040124400330,112002000240202,111240012241220,102034031324100,102100401400000,100012004202204,100022011030031,101220031020031,111100122240002,102102022002404], + 1022010402202100: [110001332120300,102101211411000,110003000420200,110243234240200,110004014411012,114110200212210,112000120232022,102041220200010,100002320113100,112240200202201], + 1140040310301200: [110020120023302,100043120003103,102421012023000,110002000410040,114203412342202,101022411030002,102000021442024,100030314100004,110400302114103,103001021240120], + 140032400120003: [110042220002210,110410200100200,102113340210000,102221200204022,103021030102410,100004014300341,101010200321421,114100212211004,112001402002232,102101024000110], + 1141141021111132: [100100014100021,102110410204321,111121012212042,110014000000224,101021001114141,110022134200011,112320030202004,100210001002400,110000031103200,112320001130240], + 1000410203203000: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 1010230110002204: [100002100100210,102420424042020,102000430221040,100100000422320,100102020411200,102100012002000,114221030000011,101320224220103,101302131002410,114140120222220], + 200001414122002: [110213100122010,101212101023221,112120222020002,102130100222100,110200204432001,103024041421002,102200034042002,102030004010204,100104011041221,102400321403102], + 220212141114021: [103000120120104,101013004222210,113011021023020,114200002320001,114002420023031,100141124233132,114210202320142,100041401221302,102100004030000,110224002122223], + 1104000000000031: [100440031001120,102020200223310,103220011420242,100031201030331,112102102302000,100141011011032,102141231343401,101231104200000,100002120200101,102112011401424], + 104031100202000: [114201204111222,103300004021200,102004204041000,100012004101221,102301101004100,110432112111103,101410020300143,101000100342143,101012111001103,102411021400120], + 1141003240002100: [104120011242011,114300000000002,110020002104100,102111400202120,102000301101102,111122200021102,114032234033303,112400034040002,101041100300001,100000020201032], + 1001220032421000: [103112004030003,103100311424002,103040224000100,114323010000311], + 1110022213023042: [110022000023010,110200304432400,111222404100330,111002234114103,114221002303200,110031330120101,102300200240230,114014032333420,102001000221040,103110220120102], + 114131300401202: [102021111412201,101201000011000,102322124114210,101401221011342,103200004024040,100300224213123,114220000002123,100010214302012,103234124040203,100200034220322], + 330001100124241: [100020220410142,110000412003001,102011331131302,114000230023300,120202201010210,102021204013000,112042024000020,110022100044100,114400200004310,110003000024101], + 1104121202000102: [110202032123210,110412244220110,114001002300430,110101230100001,110411130100013,110000022003412,102401200232302,102230221100001,100021044210012,100112224301402], + 1100000000300032: [102104101340301,110014010012200,102110304020201,111012000021241,111303012201100,102224000214240,103130024002204,102113122004204,102000244000000,102112001341014], + 120100044024000: [112002204004403,103013001430040,102004201410402,102401244020424,101104121111112,102141032001100,102014004000221,102002240210000,100100220024041,114000000023404], + 144402423233242: [101222101202341,100020220410142,110000412003001,120202201010210,112042024000020,110022100044100,110003000024101,100010024302100,100000011020412,102022400210202], + 100140013103010: [112000124022430,102302120210122,100400300013000,111010012201220,101002104002020,110212301300020,102220211302322,102202001300342,110010222000110,111322300013200], + 1143002012123401: [411010033020221,202013001110004,1320010210001300,112012111114213,102230004030112,100100221012100,112102000202302,103013200104400,111103304400022,112122400230241], + 222222100020032: [110011202100142,112400102013231,100001120400212,112030122000211,102023424004210,100014140201220,111004012200210,114142122200022,100413131013301,104131002103204], + 1431402121001044: [100031120101224,112012004004324,114122220031004,103040024041111,101004004213014,114022214031210,103234100101221,100010111040104,100001200204214,103103311424020], + 1020104021310000: [112113214020100,103300344012201,102010202004402,100000130013400,111130312211003,103224041400220,100001321032243,102104244000010,101001010300404,100201104224131], + 1224102220311030: [111214100000104,102103034004032,111100014404020,110044014410012,111210124134403,100200044320404,101022024010403,101402014002002,110000110020241,102200001112320], + 131100004122440: [110101420400120,110110420012114,102103122004020,114021020011222,100040204304024,100304100140104,103120000104023,103010100101110,100001200121301,101102210330301], + 340000233002332: [112100124023402,102000224000011,101020044011003,100032301041204,100410304320220,100002414210010,102402000204104,102010042000041,102242204040102,102020111100200], + 1020103101321000: [101221121020230,100004110000301,112022200234200,102100011341140,102320231000001,101122031100000,111222244103200,102042310203001,100101021044000,112230000412212], + 110000202302130: [103311011404143,100021220010031,100000014211030,111303012201100,111020322144201,100220121003120,103240214031201,110210120000141,102212021120100,114021034021244], + 1040324330002230: [103004301434100,111322432204020,100003300001101,101100004204040,112120202314224,111321102010100,110141204400012,100010011202403,110102020032300,123000123110000], + 124031241220010: [110120144200000,114022412330004,101200221022044,110241112020204,100002004104004,102100104002224,102100224000210,102310140240012,100014204201000,102103321411004], + 1143010202102120: [104100111240003,100010101020412,102203101113311,102100200221304,101011024001101,110003004210404,111232402242032,110142010120100,100103024102040,102112200210412], + 1001340224020303: [112003100241220,102204001121032,102004000220013,114130302313120,100102100000410,114003124010140,101244001000204,100340000140032,101110021040110,101000030322212], + 131420120012011: [112124004022322,111300210014020,102103201320411,100100031043410,101033214211000,114001100024243,114100012204104,110141112044000,100034244303010,102003104000032], + 220022110040120: [102333021100220,111314044130000,100102204234121,100403200032000,114213314002002,102001301320420,114110034120300,114001400040401,100100411202320,102320241001011], + 200310122220124: [100002311020211,100131144234022,110420202121100,101001410340301,103122100103002,100021001220144,102113040210400,100022410420203,100030424012242,100210101002121], + 1102012014000210: [110000204210130,100100100422103,110020134410001,103101001422002,102204004042041,100021140000322,102101002004300,114100202200202,112000020210140,103230410100410], + 141100400001020: [101300124221002,103311100112220,102112002004120,114400004141104,102142234000020,114402044140023,100314420140013,101401204040200,102132004004123,103030100142040], + 222123002211100: [102442211414022,110122001010214,114400322311044,111231012220013,110022300420031,103214220100013,102000324040402,102340301000304,100023011030111,100101220101011], + 1102310002000110: [104100012102004,110030002000422,100402431012022,110040002034100,102031024013013,110044020020202,102122410220401,110201434430102,102000200222121,101002020342002], + 1001012414012210: [110041030000202,114412002310123,100000300100343,102001410212441,102000104000041,102100034132002,101212430302203,121000000000100,100023201030204,114200010001110], + 222011100203111: [101010314000000,110202104242120,110020124201031,110041012003012,100111231222104,101000201110001,110021000414343,112002212311322,110014400000110,111402114420000], + 201203203400031: [110202032123210,111122004100020,110412244220110,102411314024401,114001002300430,110101230100001,102200034024120,104102130014402,110314042102142,111120122242010], + 102232100103230: [102102031403230,100024004210111,102002100222202,102001041100103,101001100320224,114021004100002,103201330101022,102140020210040,100100210411410,102100320220140], + 200242000102421: [100402004300002,111012104400010,100100004100200,103120140210020,102143211343014,100112000410320,110124044400220,103002110114402,102100214000001,100100121010222], + 104041102100301: [100111011011011,114014112300100,114030034013101,102400124020001,100002100412200,100102224234101,101013004001421,103000014011004,102010321411140,100031120413224], + 200424120033103: [102334004110232,110311331003000,101020240300003,112300032000100,112021334001000,101000100322140,100144430411240,111000024401300,114010010002314,102321040213311], + 102023020000231: [102302024112212,102042221101230,103000020120303,100123000422310,100000040410034,100010030122310,100003314100400,101443104041443,111210102220243,100023004100022], + 121200020020031: [102210000240404,114320124031023,114220020213314,103141111442241,112020141130103,101020001101203,100040324202211,102020120223201,102201011122031,101041400320310], + 211011003030122: [100222311000201,110200132020200,102202201121140,102020031103041,110422400001143,110200201212001,100000214302242,114213124102300,101024020302210,104020040010100], + 1132404221203002: [102110201342300,112121032014014,103334120114003,102102011401410,100130204300200,102330104110220,102333014110114,102043031412211,101210100300100,114200202320040], + 1010144011104233: [112041212004442], + 1210200310002040: [110204034240010,104102030012121,110111222040014,110300142000143,102141002000040,103010000120000,110000011100204,102100111413012,103442014000100,103021000144000], + 1020040000223040: [103244400103103,100002001040031,120220110010340,130024200410411,103212104041004,110012422200110,120100430000232,112314010200014,111323304123020,103043320110242], + 121002002002112: [114040300043111,110203111111000,114010030024204,102010201012014,102041204000002,100402201004014,100420404320101,102123414032304,112401014040034,110021200002102], + 1404231040000003: [100103030021200,114310312320104,102300000210120,103010014034004,103222000102010,100001001020120,110211011313401,111211244410020,100111044232401,101002021142202], + 1101120110020000: [100001300102001,112033124022002,101013114001130,110110102042312,101004104010020,102001014003100,100243201003120,110010002004203,112000012300102,101121120321230], + 110310201330140: [110203100104014,110314122221300,112042210240113,114310222300212,110103204400311,112100104042330,112003022001322,110200202021000,100004030410001,103414000120102], + 1022111200121021: [110021220021121,103322424033024,200003230020033,100010130140100,110040000440000,110010010431112,102103201412111,101140114004004,110210004212240,112011011132021], + 1123014010424300: [112213000200301,100003224334120,110204130004030,110202120003032,100322004314021,102022010220223,100404000020012,102343301100440,102410434000220,101101000330302], + 1140301003000204: [110212012114431,100001140020000,100012101223021,114002020044120,100021004302202,100121104300201,114102010220042,110132000024420,102021301441201,103103144000200], + 110310143020201: [110204004430204,110300011230013,102100400222242,102122114003140,100002021032001,102011404010000,100000011220004,114111002340233,110000210004001,102100324001200], + 1140001013011013: [110033000022043,110100200030100,100000411231000,100023001222000,103140021211010,100020140121034,102340211000200,102300231000210,114000200010000,100012024210202], + 111300000203022: [114203104112214,100040004330302,101011024213031,102302004110031,102200324111003,102200241003011,114241010002120,100040001221420,110102110120200,101210021000110], + 1120110102132121: [101244201023000,102024204003232,100103144100002,114220010213003,100002111041341,110224234240311,101042301004002,110203222110130,100040011234103,100100000011020], + 1000102000312244: [101024040340220,110002012202020,112042111120402,111311244120030,102100100200001,102110034000010,112200211100102,103000024002024,102104431123112,100142414232000], + 240004203340000: [102000001132113,102202310203222,100042001020203,102002320220202,114130210231020,111321314133000,100000201041300,100004410120102,101020104000040,102432101112141], + 220220202201021: [100003134213001,102320221000400,110420134220132,100301014210302,112400124040230,112112002010010,111000100023120,102110003003400,102401000341040,103120041210040], + 243011403011002: [112144002012040,102110040210100,100014424203222,100120200402020,111002014122111,112013002310110,110232200421003,102140434004314], + 121120030011003: [111102214104403,100132004231230,100000030000001,110302302001423,112000042000001,110021340020022,112020022314000,101010001000320,111001014111122,101003204000300], + 200143400131010: [102200041120220,100100001041204,100002001024002,114002100040223,114101002200223,102430001400101,103210140100004,110021041330000,114021404100022,111030004402002], + 213142011001043: [102003210220202,100100001202011,114104030222003,101120004004020,101010434000404,103103044002112,110020202130122,102110404003220,110202002033222,100402300020100], + 120402112140020: [114001000020102,101020040300010,100213001000212,100040201012040,100002004212420,102121014002022,100141404233000,114100222310230,114131002342130,110002022003101], + 1001103101403220: [101434200303301,102302100241110,114000224021230,101300244224432,102101120213444,102010214000002,101412101103402,100000204214222,102144420210001,102220234040203], + 1111322204130201: [110022002120332,111110230014001,100301101000021,110020140044140,100000301031020,102100104000244,100221000031141,100420031002301,101311010340421,100011301024003], + 100020030021014: [100010400022200,102300001002144,102302444110110,102420221112201,103001000142003,110310004424232,100010344310042,100402012200112], + 1020300330110204: [100132130421010,100212001012200,102041231120304,101020121032010,101302314220212,100000111040212,111130220024001,114333120004102,100402102200324,100400404322200], + 1031204314000103: [100240000032004,102000000210211,111010204401023,103142444002002,101200010300001,102211300204221,114420232314210,100301004321221,100020000410313,110301111301101], + 1410110210202321: [114000320041321,100004004231003,100020201024100,100223004121020,110202204244021,100200024121000,101034201140140,110110004402000,101031021032020,103030020100023], + 1030102031010120: [102120010200131,102312300220000,110020120041030,103001220104301,112010004020300,101042200303012,110401202021231,102201001120441,103012000121000,100240204101020], + 1000202010400001: [112032012004300,101001034002001,102000401442010,102000014004040,111020004400234,1042012320010021,221104221024023,102121321410143,110020100431011,112000034000041], + 1001012002100000: [111034014401112,111302202200213,100030241043214,101421001021031,101300400313000,101220040310221,102320030240003,202030010203100,114431310000020,100000004300240], + 1002023200220000: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 203023002012000: [100011231042030,102100141413100,100020034100101,110004424200024,102111144001232,100111221011100,103312300110101,101403004022114,102000441132020,102222244040141], + 1420200120211221: [114200024110021,102211021000220,100010001040112,100002044241100,110023244410030,110032020042004], + 1410032141012101: [110201201211024,110202000000310,100422314300200,102141410230020,110020001224021,101110020013040,101012410301010,103120001400003,110003302000101,111122222240232], + 101111100220130: [114311204002010,110004221040341,102313114114000,114004102201202,100000101001431,101010014001032,102340140222011,101043024000300,100001044241012,112210014003412], + 1022000401000210: [110241024242442,110444010032242,112220001100200,114014130041210,100001041031013,114212102310100,110224200113042,101000020301410,114000102210200,101041001032310], + 130202004013214: [112142301101040,101000130320340,101121100332142,112401314040311,102011004013000,111200122222334,100220124221000,102301024113440,100033230420102,111110004402021], + 1022011140134201: [102202310203222,100042001020203,102002320220202,100010044300003,114130210231020,100004410120102,111222214101043,101011211003002,101001040304214,103230430101003], + 1001320220202100: [100422000031421,101214104041040,100102000010243,112410034040040,103031410122401,103101000100022,100040021031201,103000300120001,100020141044111,114200000002420], + 1030000111414222: [110104110121000,110040140031200,114043010040031,100404030012420,100000101232023,100000021030000,110030102131421,102110001342020,114102302311130,100023200423040], + 1010310012100240: [102142012001000,102300120220103,114141302341111,100000000014401,101020200320000,100020114202320,112023210242031,102042301121010,110003204210204,110011002014134], + 1000130201221420: [110201400400024,111013232200403,102112220202010,102214104010210,110042042120021,112010120231202,101011101032340,112402010201300,101013411000000,102100001400004], + 1031402010032104: [100002121043000,102400234020130,100133204300040,102200031002000,114021112304224,101010120320311,101201101001302,112201011040200,100302241002010,112040101110000], + 1000042200200420: [101404110301130,102000001322140,100002230124133,110030411202403,102001104000101,100042114342002,100432101014010,110311102100000,101000030310000,111020104123120], + 1001323120212214: [101011411020120,114201232330041,101000010201420,1320010021102402,201200032021040,142321203003111,100040011432042,401000020221031,1440003320032101,100201001100200], + 114220104100004: [100222011211021,114031112210241,103201114030123,112000312000120,102120341340120,102422310203100,104134440011201,102311021104000,102104220213400,112021011112000], + 1010001031011222: [100000100100200,102010020203010,102200010200000,102001241410312,114444012310100,103140100210101,102330021000131,112041031114021,110400240002411,114432422322332], + 1020211314010240: [110104110121000,110040140031200,114043010040031,100404030012420,102110001342020,103242024032020,111123420020420,114000142331320,101114414000402,100011200100200], + 223002000202013: [103212000212121,112002010220004,103211014000111,102000034013222,102030021100041,103210214042004,102311020240120,102110110210032,102202001113034,100013020204032], + 123430211222102: [111103240020200,110022201100020,100141214304000,101430001012430,100011204100020,102100211340043,112100311104022,103443104001332,101422214042012], + 1041022013101211: [101033011001100,110014010012200,114314300012000,110020334420200,103100020210002,100100004230402,102110304020201,102321401104012,110202420004101,103004000112020], + 220123301201314: [100000200202012,102202310203222,114404010003320,100013200412401,100141011011032,111222214101043,100010021034000,103132004002020,100000241000002,100000401002031], + 311000010411104: [114221312340014,102402201110020,100311204312442,100001024100241,103000020100131,101211204201231,100000110100200,100012000022100,100020034200301,102320110240320], + 1021200214341002: [100322100143040,102410000230114,114201234002300,102303320221102,102300001001300,103311034030000,100020414100300,100040004102010,100013441022002,101200301021101], + 1440010000100423: [110400024211000,112010002313023,103013001430210,111100314400341,110003410004022], + 122001321300200: [100000410103200,101030001001022,100001240410410,101042201000011,102030001412241,101001204010220,100004301023143,114223200221140,101012400304201,100031044300340], + 210120034202431: [112133102012033,110202041102300,102142120202202], + 1002220001020144: [110201430100032,114300212300441,100000310102200,114220012320403,101201100301040,103001001421002,112114211100012,103004111240200,114040002301110,110022444200004], + 200321003101014: [103204214040130,100142010410011,102041410242244,102323201000412,102212434110001,112102314020000,100000014200001,114010002304030,101300040310000,100012124101001], + 214042040020010: [100020424300341,101021414001303,103323314024002,101004121002043,114020320040231,110220012121020,100400104302040,100012101020010,103104001422213,114130222201102], + 114110223001020: [100122004300410,102202414041044,102000104012232,114443330001442,112203221102231,112400202020003,102000224000011,103001104010010,101212040303123,100111201014214], + 100003000004013: [102323101101400,1003002030122040,202003402402323,101230330042220,1304100402114410,410142111403201,1002022230124020], + 201312314012001: [100020201020032,103100111424040,102304000242033,103000011400001,102104241412223,101400200303132,103001010101001,110220000113011,111030014120004,111020142144200], + 123030200011320: [100020220410142,110000412003001,102011331131302,114000230023300,120202201010210,112042024000020,110022100044100,114400200004310,110003000024101,100010024302100], + 123301101404412: [100300001002022,102230214040102,1301124312021400,100010341024201,203001440023021,100013240400003,1300110022103104,103000314002021,1000100400230202,121100201000233], + 312410000420413: [102430231400211,102004021102101,112002012030102,114440240003000,112120302010202,100020010000104,102124200204223,102223211121031,110012020042102,110200012121210], + 1100201112222004: [100000210410212,100202021212012,102000032003002,104003410010031,103020201401104,110020030011011,100100000012334], + 111000023000312: [100122200012014,102120400212001,100104211044110,114313022302101,114021002302020,102313204114304,112100102300200,111201424100200,112130011100011,102413141112111], + 143000010021300: [100440031001120,102203004042010,114203042330220,100020001041410,102032012000101,102102231400111,100032421040120,101004201001232,102141231343401,100002020101023], + 1202303342030000: [101010010320112,101001400301113,103101024004200,103300021402104,100020124100010,100301020140000,102102024000001,102202004011044,114003104032034,101012044004042], + 1220040321310311: [103102101422031,101421100301230,102130124130100,102022020204430,103214021400010,100012401020212,110100022010014,102000324011143,111110420014032,103004044010300], + 1001100121010011: [110002012000400,110020422131120,100001000100000,110243000001123,114024400030020,102102120210120,100402000010424,100002004301002,100103120023100,102140011343001], + 202000301100403: [102001200221011,102420000202033,101000004010012,103024000103302,101301014220002,101012044004042,100112240020023,100104000101010,114040100011424,102020000220210], + 122044001400202: [100200400430003,114420102323300,110212022133311,110404122110112,110403010000304,114100040214000,101210021021243,100140024230240,101010200320244,100100241000020], + 221001014242010: [111323002200100,112010212000010,100022404301110,110220001312011,102202210201312,102121041340001,102212444022430,114321120004122,111210012220010,111020012111214], + 220134020042142: [100002421031242,104000000010243,110441102112020,100122004323202,103040230104020,100011020140201,110300212000100,111200404440043,111010100040312,102223301012003], + 310001400100202: [110320202023400,114101420030202,100011004343022,110104422010121,110302204433321,110013122130200,110401140004202,114020204102020,102402330230011,110022202130021], + 1040120240020040: [101122031100000,114010022302104,101220040300414,1300322131001002,102300200220002,101141430330003,102121211343322,101003140301001,1320004203402400,102410001111322], + 104102313100010: [112102024020402,102102010214442,101002024000400,102240231110222,102010214000120,114023142202040,102330020242041,100114310414323,101010310304023,101223214040013], + 201220310133010: [100011301040031,102101021341002,110002220002220,114404210004101,110011001100133,112121404020102,101000000300323,102322144112403,102024001102302,110031102000134], + 1030223001041101: [114130302313120,114202204113222,114003124010140,101244001000204,100340000140032,101000030322212], + 1420104202002430: [110221220004222,111001240012300,102020020222311,102412300200000,100110401000111,102141200210120,114010302300324,101001214004102,102201040202004,102002220221442], + 1010014020241002: [102240020200400,101210331023020,102021111412201,101011211002010,100021300103041,104110411304420,101401221011342,100222100412022,103200004024040,102140002000412], + 1002410011102233: [102121020220110,100001034201201,102010402000020,112204304010021,114020022202002,114212222340440,100001040100414,110010400142004,110022011320020,110200220002000], + 1000120421000330: [111220002220100,101133410300302,132200010004401,110114410003233,140200430112430,112144312011433,110000040024442,101410044021332,100413304100230,103010201241124], + 112100110204010: [114043342242304,101014124224432,102312001000100,112430022023221,111304214132302,102023120213242,100342011001201,102020011411100,101400130302001,100044000103202], + 1240210303020020: [102111000202241,103232220103211,103202404031100,110043132100220,100202204222000,112421024013100,101201114044200,110422420000022,100402002200010,110040304210001], + 1001021020111202: [100204131213121,101012104004211,103300300144000,110320212020203,100140424020004,111001002140322,110200134430401,100000134102314,102203001113302,110004414200010], + 100041000023002: [114031022302044,101012131000024,102002024000132,102110141410402,101044001032114,100001111032112], + 1002210013012020: [103110004004310,103012301431324,114101412203113,112122332013301,1002400121102010,102113131410033,112344420200240,204130104001203,141000003401010,102221001121003], + 102022100034002: [110200140401144,100430200431021,112002020214003,100222101210111,110010220410220,114040010022000,101133104002112,112140044022100,101030201030000,102024041130142], + 110031040003102: [110013334202122,103330104030103,111200002220003,112043421121002,102212030201100,100104234230043,102010341440030,102101024000110,100401301001200,100001120100002], + 223103104131004: [100114004100001,102003320200411,103222244003021,112440114040203,100401001011010,103001204002010,100340114211043,100033001220020,101100120334014,114233002340141], + 1103220210400202: [114231202331202,100003021234044,111102032220111,110200204224211,111300042200340,101010041032322,114020042300022,100021421020002,102400004040100,111120204100203], + 130300320200133: [102142221342202,102100422004010,102420000202033,101012400343401,100020101020404,100002411021201,102110010210330,100012020410400,111111102240001,102122111402420], + 1010001000100030: [110303120102044,102120012001031,110201310010120,100400004303004,110002022030224,111234024134400,102011011131431,100204011002001,102013301320044,110020221320103], + 310002010000002: [101400004022100,101421100301230,114031212300211,102013110201200,102042321440100,102300121004222,112000230220102,112010022302321,102000324011143,102304111101041], + 304030001120333: [100003414100400,100114104101001,101023221000031,114221004002212,102100122002001,101000011021414,112010022302321,102102201121020,101000214211011,102300131102000], + 1024240120110210: [130043000011201,103240031202014,110220314242441,103001022431400,101000000001210,111121112240002,111011020020013,111014224400434], + 1414001040334100: [110021100023210,103122000100403,102023120241131,114103412201420,110014300041302,114241000002004,110020310022021,101121021020012,100424200020200,110321001330010], + 211003100101021: [110010100022010,114004004112122,102130004001001,110033242001020,110202241202130,114003002301032,103202104032224,111102200021041,102021024001221,104130410011020], + 110210212021034: [102040044001211,100220301003101,113400010104100,100023234240221,114140014100000,103003130100120,111210020001013,102111000210000,103121311240102,110401342114000], + 1404111310320220: [114031332302421,110130020000332,103034101240100,112021014001212,111201300002000,100421240012401,103020404010101,111130002114340,114204002320010,112230230412403], + 1432110012311122: [102001130220001,101410211021400,100022441042300,103003024001001,102304000242033,102104241412223,102002421442002,111131214422402,101400200303132,100240011000000], + 1042121311023201: [102012300212321,112400202023020,104400100142023,1320142020103004,101200020302200,1320024233112412,100010230021300,102230004030112,402014100021201,1002022012411300], + 100120000013241: [101400100302311,102013424000314,114013204020122,110100224200101,110014342002102,101122201021010,110002314202114,103021424001214,110000022003020,103104014002131], + 1020241130042023: [110101210013000,100404121014002,101240220300022,110120020002304,100011000202214,100000024100000,110212214400114,110012101102100,102102304001200,100010040001210], + 103002200004212: [100111011011011,100030040101021,114310102300021,114014112300100,114030034013101,102400124020001,100102224234101,101013004001421,103000014011004,102010321411140], + 130100101001002: [103100021440001,100120100032121,110000201324002,101200400331110,111201022200100,102100100210100,100002244341113,101000141033304,101011034001210,112400002300002], + 1040332320343102: [110401004221204,111112000011222,100322444314002,101003301020022,100001030100030,112012004004000,112044204000441,103141100104002,110341300400201,100000104210240], + 121302301210201: [102140000212141,101440004042202,101014201030204,114012444020220,111141312211004,114002134022331,102020014003003,102311210240304,102000000223101,100020024212001], + 212121302424404: [110203204241122,110001214200042,100021111211003,110030010432322,102032220221210,100000004310202,100203331000130,103203120134221,100002100102303,101100020320003], + 220000201000031: [101100210320232,102302001102032,110003004412202,100100311001010,102010401101200], + 1030040014002303: [114101024120020,102004011440212,103140320213200,100000001021013,100011204300012,114003134011032,100101234330123,110024000432310,102012101443110,110032220022103], + 232042120031022: [104100002100221,104310001300102,112000044002102,114021132202032,112012004004324,103001314001021,111300220000230,114110032343001,103040024041111,100110101040020], + 100203011102301: [100024000110221,101000130320340,100110020031042,101301014221122,110422102110221,102102204022310,114130014001202,110010220103020,111004100022110,101002201140040], + 1401040240341421: [101200410300210,101001200322403,111001204120010,111214204104043,111100114100203,100400330032440,102221410204210,102212010242200,111301002200002,103102040122432], + 1000400400420010: [112132212010031,114112110001112,132002014101100,112111020202401,110203022121202,100243210430220,101023114000013,112314414020000,120214141304321,101003211110010], + 331010342211000: [110123042010000,110213012044343,102430321112030,111113004102021,100012130010240,101001101031102,100203114324000,100320224314301,112200102033440,110100000101440], + 1004200222102000: [101043042401310,104001222102120,110233000100021,101113012101010,110023132100402,110010102002310,102022102010211,100021220002020,103004041414132,112112410232001], + 103440042301030: [102010130231400,101010311003410,100020424214024,103422430124013], + 100003101012421: [110000002133140,101233341022410,114100012313002,101004202403121,100304320140012,103222001420142,100000120121031,100142104304130,100000124302200,114404240034104], + 133410114200022: [100104214302040,111021004400020,102103202002122,102420314024020,103204140100110,100401200020232,114401002310000,114111202200420,100033034300421,100130220400121], + 1020044410201122: [111012104400010,100432200033101,114244120001041,103120140210020,110010011212411,100300020142022,114420230000240,111241224101013,102012100200002,102030301322020], + 1002222131232002: [110202102121414,110143020121321,112034300220110,110300001300241,111224424101114,114201014110304,112010100202041,112013222000202,110222042040000,111001422140044], + 112044204110121: [100010210002122,102301100242102,102110204131100,102112201403021,103011324001001,114003020012133,110301032020000,102110401141003,100041004100341,102021140203004], + 241321322204011: [103324221401420,110400332010004,114212002340000,103111004004332,112204340204032,101020320320424,110324011300003,100014121020424,114300034032400,110313010000400], + 110301042320030: [100000204102030,110210131301120,114102042311423,110423200004021,111200102222210,111140002113000,111020142202010,110120112001133,111004024400024,111002120040021], + 213423003000000: [111120230020122,103100221440010,100021101000000,100113324103000,100001100411302,114123420002142,102023021321020,101000304000400,100040401020413,100000024300321], + 1030000120201004: [103002104012101,114021000012031,122000430101030,114000022300301,100311000141022,114210202322020,100401301000011,124210120032121,100314020103003,120330342110101], + 1013400011031002: [110102224201130,103301201402204,100021020124002,102104131412412,114020312300021,101320040302031,102400204043012,114010102300010,114042014014024,100000000200102], + 110004322311020: [102000004002101,110202000000310,100422314300200,101403014020203,102141410230020,100042030120422,101134224001001,110020001224021,112100000200031,110003032000041], + 1212421124040004: [100011001021002,110000141012003,110112301300000,101040100004242,100003000100210,110000040041001,104002100004121,102443320233202,102402001113222,101000021032102], + 134120020401020: [101230004040022,114244120001041,101021020324310,100020140121034,110010220000210,114021000044211,111241224101013,101113020300321,101312014223102,103201044030202], + 1001042010002000: [110302302001423,101010101022202,100013211002142,110104000024100,102211204000440,100200001001420,114141024004011,114140044002043,111030424400000,110202221212123], + 131103024111001: [100100331000022,114222040214020,110200004210000,101000441140230,100142221012003,100100030402001,110132124400400,100121221022103,102022010223000,102120124004020], + 212402003000222: [102023211411003,102340200224222,103212000212121,100100011010220,100124011040300,114114414122002,114320110001030,103211014000111,112120340203021,101243010302200], + 1402202200133200: [114210424101200,100420110312244,101420014021400,112230324002000,112320301100420,110101024402203,101122000320210,103002400110231,100013100412100,143000203203020], + 200203001014102: [100011110000122,100013001221300,100004014211122,104100312101104,112034122000441,111130004400001,100004010001204,114411102310102,114102032210440,101022241024011], + 101023222400410: [103114010100442,110400222110100,102120244001000,100002411024300,102042041130041,114120444000124,100110304233020,100104004030002,100101000402002,100113011000121], + 211411002001112: [110020001310000,100310201003000,110412121110214,110142300120000,100002201032401,103012011412220,100240010430203,103210331200130,114300100002210,112040101120100], + 1002020102020112: [100000100120300,114202244112111,102110202001010,114011404103142,114041002212302,100043200102020,103332044032320,100202121000302,114040002300000,104331000040420], + 204000203400200: [100010430101320,110104011122301,100002214312112,111021344401134,102000211443214,100024000000132,1300003000223100,114020004120130,110010000020002,101302414221332], + 133401111043112: [101200000304000,102220011110041,112014402034232,102144032001002,102110000210220,111303034134331,102010200221212,100110004300112,114023240040131,103000000120110], + 122200020002210: [100000400100222,103004324000021,114000002334110,114131102312120,114102004141000,100402021000110,114142022200000,102212200201003,102020412021404,101030101032043], + 142012021144020: [100104010021241,100004301021110,114102102344110,102022200223242,112142000203203,100011210102401,102110111023211,103001011422133,112033011120110,101211004041120], + 224000000142022: [112200004010400,102011121102202], + 1020400302400013: [101410411010012,100203011000010,102221104042021,100140001011002,1340010113012333,101201200300020,100000024103201,114201003002000,100100221223042,101000401120424], + 221332040100231: [102110201342300,114300204032002,102000021444112,100003010413400,103334120114003,102140341343300,100130204300200,102001231444003,102330104110220,114100304142330], + 1110203112200004: [102010114022011,114002200000421,101020321002002,114302210010001,114030004104220,100104004301000,102443211401140,102301041000014,112002002302310,112142011101404], + 220111221200200: [100200400000010,102100014031110,101020020311410,100100301000200,101000020304001,100100340412100,110030104412010,103210244041141,112010410240031,110100332004011], + 1100020000001301: [114021010023030,103422000104202], + 110013112003003: [110120200000200,103020040141031,102310044114012,100130431023023,102400204201010,110300400000232,100130014234331,110030224201200,101022441110111,102032041131131], + 201100201120144: [100032041021210,110004301222000,114310000001232,102040041320010,103203401400132,110104002010100,114142044120310,110220410000040,101030004010034,102201411100212], + 1031120000004100: [100032041021210,102300324010203,100030020011022,102040011121100,114310000001232,111202012222402,111322234130000,102040041320010,110104002010100,100030024303023], + 100303110011001: [114002044012422,1240210023303321,111011220004001,121410130210200,100221110031000], + 1440000300001002: [103004211400012,100001020100030,103000004001200,100001020104410,114201300002200,100231020101032,111220124101004,100021004100412,100100011000200,102121010214421], + 102240031203001: [100441224303402,111201024102030,100000211034102,110100004220111,100010000114111,100001034200114,100000401042204,101002321140010,102002004001210,102013200241320], + 121244010213214: [100202000030042,102031000211000,102202131004010,114211132343224,103040004012200,102200114011100,102000234000003,111314100042040,110224010010021,110011002010023], + 100101013002202: [100310444310004,100211001204102,112333412022030,100403012200100,101411021100200,101300001000114,114303202300104,112020044000400,103230004000322,111201314412204], + 1123010441401100: [102422114040010,100022041001002,111240340004003,101204400304011,111101222244030,114032424122040,112011012004300,101021401003220,102020004001311,100301020420101], + 132112214304001: [102211230244321,112121214040022,100034244210020,100041014210020,102401221402002,100000030100102,102102011342302,102140200224200,101001244010120,103011014042120], + 242401003413002: [101020024212042,100041204212120,102113110210240,112423424042102,100320431000002,411200101402221,100120214230002,102440100200000,103204200103440,100210004104001], + 1021443140024012: [110020001310000,110214024430312,100011014100041,100310201003000,100212341003212,112013212032000,112010220224003,112001040231401,100200001001300,100012104313201], + 200222132040200: [102222131120032,110021130004103,114041302322043,103204324031320,102310204033140,111222012243120,111103110022000,111102310012110,103200011404234,114000422301302], + 112403302020022: [101410411010012,100203011000010,102221104042021,102022014002413,111002134113102,1034200000211010,1340010113012333,101201200300020,100000024103201,114201003002000], + 142220003430002: [101042410301221,110432300102000,100011004102400,102304000210204,110040344210011,100020120101000,100003200020112,112143144020012,103231224012042,101000100340001], + 1100002000103020: [100201310000404,103100334030202,102211014034100,111000222232122,102301024020102,102240031000040,100102204231301,102102110231403,102303300220004,100001131030122], + 1010142013410010: [112011011111323,102133114131312,112210104000224,100003020002222,102302224113320,112441402014033,101211120304230,101123210321002,102333100201022,114421224140012], + 134140444202144: [101221020040220,100103104302044,101041030320401,102141212000200,101203121020430,100030010102102,102100104002224,102020004000014,100000211023014,114144014122041], + 110041002323000: [103100030100010,101400004022100,102013110201200,102042321440100,102300121004222,100042000102010,112000230220102,102013000202010,112010022302321,101040224003400], + 1003121301200004: [100030004300300,114310020001102,101111004022001,103002304010110,102021001414200,100404400020001,101221334040104,111230030010400,100040021024200,114404004120002], + 100001034000204: [100000010411400,101002304210122,102100340232410,102144312001130,114400240003203,103000320120003,102022002000202,102022040203201,102141002000022,120103240002010], + 240021120120021: [110000000003200,101041204222101,100024024211001,114031000012100,102110001342114,110200000004322,114342044032200,111110020000001,101100401022000,100400000010022], + 1023020011001040: [101214104041040,100304011002220,102012204010044,114110100003101,114240032321200,110024020122322,100020141044111,114200000002420,101024420304241,110204310112224], + 1002244040014321: [100020244100302,100002200412020,100102000423142,102000301100100,114410012310230,102024011413201,101300414221100,102122421340210,114001042203020,102010100203212], + 102111000200102: [104101000012210,111010200042110,102102330211000,114111104121010,110410241112100,114123000000123,100200320032100,100014441224023,111202000002022,103003004002202], + 122042401000000: [100002020413201,100000204203120,102303121002022,114000012300000,114040004102003,102121314020202,102101402001102,110004131231204,102021030200100,100003020100001], + 1043104210040200: [100400220010240,102020200203443,100012200002000,110010114203300,100000000413102,102100111411342,100032004200002,100103114232142,103022100122202,100441120030002], + 110300213030242: [103000200111020,100100100412204,101424100304000,114004000022042,103003444010014,103121120114230,100012241220110,110002111042010,112420122022130,110002321321021], + 1123400001001000: [100000014211030,112200122022200,111020322144201,103240214031201,110210120000141,102212021120100,100010001043004,101041200344232,103242010103121,102220334043022], + 1140200120221241: [102201204040211,110020442001124,110024102010002,100100101220114,101324030311010,101402001013023,111433000002144,100010021211303,101010231002430,101001010320221], + 1000432212100423: [100010101030000,112400024011003,102012141440022,100420101011004,114030424122003,114000010031201,100013001020211,114204000003310,102020100231030,102100301021042], + 244323143203122: [102343230224321,101200221022044,114201104111034,102310140240012,100014204201000,102140114004004,101232240300002,100141101044100,102132401400002,101022121001000], + 1142014042201001: [102044104002014,102022000220004,110210001310230,103001220104301,100010144303000,100102434300310,100421200001003,114024200040223,112010004020300,100133404030004], + 1004010000032041: [101040014000130,103303404020012,100210001002120,100220224220102,101000021141201,114140024000003,102010014010000,100000014214334,110034420441200,102020120222102], + 1003044002221200: [102013424000314,114013204020122,102144201343034,110002201320001,110002314202114,100430010431044,103040201222041,110111221000100,102341131103201,110000022003020], + 1021022210032144: [110012014411212,110131021000040,102130211404020,102142024132020,110222004210002,114110200232130,103101400122200,100400020013000,112011310234002,112414102021100], + 1101100031142400: [102203344011410,100021324100000,102103430210003,100012014300120,110100120400020,102414014022212,102012220241003,100032000101014,103130020213032,101430211012120], + 1112102242103130: [103040031403031,101030014001004,102012421412000,100010044300131,110144102001321,100020304102100,100013010004000,102200000204231,112020022000410,111232100010040], + 121002012020022: [100003101032010,100000204100040,102410111400000,102023104012330,114001412302040,111100022240034,110204100002100,112131400431402,100400202200141,114203204001211], + 1122021000011001: [103002001240043,112023420232024,112002002003003,110002120000000,102340001102023,101202101000104,102311330240430,101023101000220,102100034001000,110001200421021], + 1030004031401012: [114031022302044,102012030213014,102003320200411,102002024000132,112440114040203,100401001011010,102010124013210,101114000330410,110100331003020,101011104000212], + 101210301100103: [110202000000310,110000010120043,110000302030030,110301311303102,110103111120042,112100000200031,100003200120040,103120001400003,100044041024214,110030124410000], + 1013220022033100: [101240210310204,100100220423210,102000111441024,114240000000041,100211041001012,102032000223300,101013024000102,101414000300100,114202002320420,102400400200100], + 1014240104120122: [110220100000102,102100321320100,102102011414242,100041004100221,100000000412112,110000010033022,102330040242220,102140121410131,102310400240000,101201340300430], + 1001111100200000: [110411010000101,1300004001031100,404130103212403,114124400000022,1100210001041103,1200020222023401,1042431100100100,102022400114011,110432010304000], + 1010130302000100: [102024124000001,102020010200102,114104300220204,102121300201244,103001021431101,110022030110040,102101200231432,100042000010010,102000331132232,110040300001031], + 1240120303221100: [102000402041014,103204214040130,100142010410011,102041410242244,100022010411004,102323201000412,102212434110001,114240044000100,103140031420300,112102314020000], + 330023104004402: [100131204300010,102102020203131,102230214040023,100000301041003,100202344123110,102012010214403,112410102300413,101031021112020,102124000210033,102221321120312], + 1011042212142122: [110102042010220,101020124000413,114013400011030,103004104010210,101220024041000,102010300201414,101413004041201,102334000243030,112224012020000,103200114030201], + 1110104210010020: [101010101003222,1304024102134240,103200344020420,404010201000410,101014020300010,1440124410104100,110000204412220,100300421001110,102030001201100,100100014220442], + 1000004100000131: [102010421413322,111210044101201,111123014100000,101042230304321,110011020002013,110100002212322,103103404004112,100021024100103,100200201000403,112142011101404], + 122201400020101: [112001001112001,100310444310004,112332000411020,102431200203321,100211001204102,110002400042003,102032010241003,102403204000000,112333412022030,100210124104100], + 130131304010113: [103101224000011,102200042000104,103002000104400,103002144042123,110114021000012,102304204110040,112020004002110,114242210004001,110031404200110,114033020020202], + 100100222200020: [103140044032100,100032224101400,114100004121121,114110004002200,103033044023040,102403101400210,101021410320100,102301000241011,100001301020220,114023122212301], + 1131103122330020: [114032234033303,114300124030100,112011204004112,110102022000200,114020420030200,112431104040041,100012014202441,100121114230123,100003120410040,101040334212110], + 1423300001022042: [114200014002201,101400001013200,114101222204110,102143032001040,102302004110002,124013121333134,101002314000000,100330000141002,110011200020113,112433102023242], + 1011124220303023: [103104120102204,101221311031011,100004301021202,102232010200402,100400040013021,101323244232010,101232000302102,102210420240403,110400331000311,102201000201000], + 1002000120014000: [102001204003131,102101041340032,103010110120332,100012020204300,100001104301010,102320110243020,101002020304011,102432314021013,114001400022003,104010000000320], + 1104033302100122: [111101144102000,100020100101101,102300310242221,102024101321401,114020000020300,101100021101232,103000001401041,100000134100202,100000321040000,102131000201203], + 132404344313001: [101202000300323,1202120201221210,1002004000020441,104140041004101,100000144310420,411011320001004,144200003100020,1400102001010010,1002004011000420,142110112121222], + 322023000301324: [110122120100022,111100424100021,110111121011004,103001020104102,110200422113400,112000000223310,100002214210110,100011200201230,111001002201034,112024144002202], + 1010420322320000: [100040000010200,110011200022002,112210004002112,110023202200020,100020010423201,110221220002400,110040030023010,111242044132200,101041104000203,114202432321030], + 1102400411112430: [101020024212042,100041204212120,102113110210240,112423424042102,100320431000002,411200101402221,100120214230002,102440100200000,103204200103440,100210004104001], + 131103404001411: [110200002031302,101403220331230,102040021121030,100000204130001,100412441010422,101040204210210,100000201034001,110000324412304,110000201230100,112020024000010], + 102221214200042: [112312022021021,101200101021000,101430004040203,103000024014022,103122104002013,100040404102010,101020404210020,100001001021002,114200104001010,114040414014202], + 1002001202000034: [103211200100400,102112231020231,100022004300020,102320000240102,100042144200000,102030304001101,100020420121003,114201204111002,103310111402022,100014001041210], + 1040022040342000: [100202440410010,1203210010100211,400114001102410,120200122422404,1031104420000230,1040100003200241,1020220210340010], + 220340041000100: [102023324010020,114020310024000,111131002212014,102120311402124,103140124002022,102123301340300,114300110001310,102000100221400,100034300102201,112121004021023], + 1200033040041200: [102101324130010,102100441341013,101440004042202,100100204101010,101200200302210,112100002302240,101430001014014,103312401404300,102103104134040,111141312211004], + 101104142130230: [110002022002032,110000242002021,110042130002002,101010000324423,102421340201120,100002204300121,110402332010103,112400242014010,112410000203032,110020400021220], + 1002021202004000: [110402424222014,101001011114020,100030044100103,102012040223003,114022012202024,112023212001400,100002110014312,114042004100020,110320042021132,102002101123010], + 100310120404403: [102240020200400,100042111220111,112220100202000,100042041220010,102101134004010,100403211010100,103240301400123,114102210214041,100021300103041,104110411304420], + 302004004042232: [100401140034220,114002002300222,101242004043300,101013111000000,102102131340404,102420041111041,112004312310301,100040121030000,102000404003020,103111020223101], + 134020334240000: [104100421240110,110213012044343,100042010103431,101001101031102,110041221200014,110301122022204,100242130430022,101400004022212,110233020402400,111102130021203], + 112213102313043: [110004020020022,114032412303041,114322024034312,102143432000102,102040010200101,102200434012013,112000301122111,114001110033210,102100201400122,102013120200110], + 100213022010032: [100200104321000,110000110410110,101021000341001,112032302000220,102004301444000,111133030010200,102103231340304,102100010222101,114000044101422,102020204002424], + 110112122200421: [102334000243030,102311321002232,100020420123031,102412020234414,102202424111200,102100040220330,101002041002243,102402001110220,101002424214013,101121201011000], + 1120231211123244: [100422000031421,110302040102004,101032000323012,101402114042420,102220021120430,111341300012200,100102000010243,111302304130401,100024334203210,103031410122401], + 1002020200101320: [110033200023234,114034120024020,114202042330012,103024110101112,100120244232122,111434000000313,110202000012302,111010012202230,112400100203420,100000004303002], + 242132100033200: [102300100220200,100101021020221,100121014300312,110220442220001,110210142123042,110110400003300,101000201143043,111222110012011,101000040310042,103221214033302], + 1121104310010100: [114400022321400,101302340312230,100400122201240,100011101222101,101000034000203,100200321200200,112044200243000,100002300421000,100202140430012,110200301210031], + 200130111130033: [111302204133040,110300000011120,101213020304210,110422011240010,111020010022310,114011302300101,102420021400002,103221200100302,100432211002022,100424444303100], + 100101020122122: [102012021321102,102141000230042,102002000221000,114044020020230,102321001000211,102242130202110,100002031020102,110200440000121,112400204040200,102100301341002], + 1112110121000220: [110011414240022,100000200202012,111142010020301,100010044300003,114130210231020,103301410110110,112114324040000,102124031023100,100204104320231,114002104020100], + 1401002203210440: [100400040010041,112110020420002,112014002002044,112012242000021,112000002300002,111000322200012,101030010320010,111403000002120,111001212200010,110000240000033], + 310031013104114: [112142301101040,101000130320340,101214440300301,101121100332142,112401314040311,102011004013000,111200122222334,100220124221000,102301024113440,100033230420102], + 122141021011010: [100020031000013,100024004310330,111100012111200,110410324244300,101001001000302,111034020021310,100110040411303,102101030311301,114121012211212,100223401013100], + 1421300233313030: [114000042300021,103213434031333,100002010120410,112211204010133,102222000201000,101011000320010,114001202300211,103001104012000,102001011441044,101143020011020], + 1021011021102110: [101041030320401,102141212000200,101203121020430,103130021444021,114144014122041,100022001040322,102104402000040,110020030024004,102112204131410,102324000240024], + 1010222134200140: [101040010311213,103001101422010,102014400223314,111012340040202,103242404020222,100103020004000,101414220302220,102100411121420,100112304000043,111403422104410], + 1040220210344241: [110021002130201,111302202204022,100120231204012,103002011422011,102201411002430,101023114001014,100000110120224,100002100122314,103240010101410,112110001102000], + 1012013102314000: [110240301111040,111123014100000,101042230304321,110011020002013,114200000003241,103103404004112,100200201000403,112142011101404,100110120023012,101042044010040], + 1003020000201402: [101403014020203,100402004300002,110003032000041,102143211343014,100112000410320,114010340043300,110030124410000,110124044400220,102111010200000,103002110114402], + 220120243041121: [111122010010414,102040404041112,114140030222402,103331304032010,100121311021322,112301120200041,111003302200334,101000200321321,102440000234100,103030100144420], + 100011310002320: [101041301000320,110311142023232,100210104322421,110100001200142,101001021020212,102401001110000,100022340021012,102002001133122,100040020103014,111131044101141], + 100120221000001: [100010231040220,121013200410000,101320200340302,110012000122313,101022200313121,110100300030021,110000121321012,103242034022234,114111300220301,103014441410102], + 200220202301120: [111311002203000,103301000140120,101033220300404,101440410300202,110013002101010,114021104100043,114401020031002,114020204104030,103243024023000,103232031411102], + 104430000240433: [100010241020042,110301222101042,112000303004042,110113014221020,112003204004010,101202024013411,101100401103020,101432320330300,103440004000121,100430304100000], + 204131021421012: [101211320300031,112230144011204,114100102340202,101044214000034,103103014000220,110321202023302,110100110020132,111010224112310,101000320324202,103000000102202], + 111033003003001: [114011420030140,413240313440033,1020020141223341,1040200130322041,1300232010010331,1030422101440422,104140041004101,121421403104300,120023100030211,411011042301123], + 1000213304012212: [102322014113341,101022104001221,100040201012040,110021422000000,101120030330110,112021004003303,110331012224112,114100222310230,100011120000004,114131002342130], + 1001201221030030: [101102400330110,112030001120440,112000014021000,101024014004200,102001004011002,111003000020010,110432120402013,110213022123233,112230002033202,101231220303431], + 340020400130202: [110040022130003,100030430422242,101120014204000,100100014230110,111002132202012,110201004241002,101000131142230,112001204023241,111311120003133,114022024012213], + 202121222001123: [111100214100402,110021130004103,114041302322043,103204324031320,112430002022342,111222012243120,111103110022000,100241004324000,111102310012110,103200011404234], + 302202022000201: [110102000401214,100100111044040,102120230212201,101230001020030,100013014102414,100014200010022,101004204210100,114031424101013,102011001320032,101000101002401], + 242212000000112: [100010020101222,101222104010140,102304244110431,101012400301024,101223214040013,102421204023110,100011000201002,102004230222000,102034200222100,101010121032041], + 101222002421002: [110420020103322,112400204042221,110400431001201,100030101232000,103122404000100,101140030330020,102330021100410,110432100401100,111102012241200,111032004402102], + 120010214010021: [140203123020300,114010230023434,144203403221310,141000201412111,110004030120020,100332121000004,102301014204000,112040314000200,114210414000324,103122201420410], + 1121000310412032: [102040431121110,101221020040220,114111100021420,112024212301420,102212000200124,100300310140241,100240134323001,102141212000200,102042000222002,114402104142102], + 1140202000411022: [110212022124220,100003100410042,100222034340301,101440044041401,102130124000000,100032310000111,101121221022304,100101101020300,102113131343200,100444030022201], + 100203040101433: [110104112010103,111102004100101,102202414041044,102140014001101,102021100220101,100230120001003,114000040010421,112042110220004,112203221102231,114022400020320], + 110012114220400: [100242024100001,110410021002000,112042012000041,100020034311000,100001241033300,100024211212040,114300024031112,102000000222030,100301224022420,102331201001312], + 1141100012310001: [102111040210242,114110000002430,111220014133002,100424220032043,114013422300032,100131414303044,110101101120302,100040201030342,101012201030310,112032220240044], + 122000414221301: [110011110144000,114402014112002,140400400201014,102340040222321,100004101020200,121022000104032,102402040200201,111041212200040,110013004410001,120221112100202], + 1410232202140101: [100023421041402,102120031140142,101010224000130,100210020410010,101000414002041,114034422302101,102322004112023,100222044100141,100020140002030,100023401221342], + 300201321024400: [100102224234002,110400444243022,110131001002021,203201100012000,122001000320022], + 114210100240102: [100012341220120,114010144022003,102301104110010,103031220102401,114100242200433,101420321010000,110133002013103,100002101020002,100031200102014,100101004301013], + 1020420002111003: [103244320114100,100032011000241,102311011000014,112031121113040,101010300300110,112044414003133], + 110021300121042: [102102000233342,103302220110131,110100111121002], + 331333440004000: [100400102201130,100000000112010,111011424410402], + 1412300220000021: [114201010001201,100030024300201,101041404002420,102220310200014,103231224012042,100040300102020,102400110230001,102101011342100,110012404201130,112221002032400], + 120304121003123: [100042320001030,110024001010110,100100014300230,102043104010014,100001004300242,111120044100110,102200201110443,114240314000100,101002411030000,102002324011002], + 1101001030310020: [103020031403100,102200401111200,114003104031111,114000044020204,100102020411200,114200302341234,103002110100200,114420002322003,103202430100244,102302331003300], + 200302221220221: [102011214000304,102202000200010,100042010200121,100004300100000,101010001000231,102340031103401,103101010110042,110422302110041,114031100030401,110214014241404], + 1100010401123032: [100011004343022,110401140004202,110040002034100,102402330230011,110432242020141,102110334020204,103200001420012,102120020230022,103102400214410,100232300001102], + 102042210123102: [102422114040010,100022041001002,111240340004003,111101222244030,114032424122040,112011012004300,101021401003220,102020004001311,100301020420101,102002202000000], + 1003020040020124: [101020414010211,101120204002140,101142004000232,100040020201004,102000034000000,112400200201000,112002112002220,100012304300004,110402030400142,100400320013200], + 220133412111101: [102103411410211,114142204000011], + 1120402011102401: [102002040220110,101010201030113,114012012300010,102141220210212,102232004040004,111202024134001,111302120011012,100002314210021,103101031440430,102310141002001], + 130001020112003: [110401410402040,100020211001002,112012000223204,101131001100412,100000121220100,114031120043120,110023214202401,110232202123140,110022040430124,101442404020304], + 102120132020100: [100010401042400,103000204010112,102041400222231,101404001011032,114121224001011,100204200433412,103430100132341,100400040020412,110340242204300,113013410103100], + 100001110111332: [110100202042123,102222004033120,110110001002120,103000301410200,101100111110312,114400320003004,113000310120101,110122101320110,123313001421440,103421301203240], + 213200113002004: [110311011200000,100120100400303,110202202032022,103204021411022,100101020400000,113112010233312,101104020320044,112004200210302,103213100102030,111000304400002], + 112400202412040: [114013342210210,112430012022003,100102204230412,101000041144313,110141012040443,102200001300021,100123020000002,112020202302001,110203321302023,111114002220124], + 100002000000041: [100024000110221,100110020031042,101301014221122,110422102110221,114220040000201,102102204022310,111004100022110,103030040121410,114040210022000,100404400013222], + 101000002402020: [1010400230221020,103034010121101,102302200210010,102340120222440,111041202200140,111300400002313,111101040014040,100023014313010,114021040010311,114140004123122], + 1000420020040022: [100021330000403,102004420240202,101302040341100,110040000001400,112101400230241,102110424004111,114100020221400,112020102003000,101003010300000,101020014210000], + 220120002330020: [111000000010022,102040001123104,112110001103200,112044010213042,100400100013220,114300202300030,103401140121121,112100122010004,100100240010030,110010214201300], + 1010201214230102: [102431111110001,1003002030122040,1320124301012211], + 1122120421000400: [100020300200110,102342110212020,100024024200032,221123404200214,100021024100301,1101210010010223,1300004102024404,100000241033100,100421001000020,1300102043130042], + 1010001010132001: [100002100100320,102024401440202,102110021342213,103200210100110,102440031411200,100023014340130,114214034100221,114202024111304,102200204021004,100113210103120], + 1002000330130202: [103001111221030,110042400130000,111200020004203,104101201240100,102301112004021,110000011012202,100201230412211,101301000314000,111010002110212,111121022221002], + 1031020030110320: [102010424000101,100300121000420,100402431014100,112202012030100,100043300401302,114003114024220,100041221020214,102103224022010,114020012301024,103021041420400], + 132203220040210: [103101200221334,114021000012310,102003040210002,110041001300210,100100304301220,103200004030010,100400414300130,100400231000200,110332030011233,114000210010231], + 221030033040112: [120130001004000,102120140212001,110102030010210,102220211120002,101400104042212,100000021022400,1003022312322100,102001244001224,103441112000230,100010030100022], + 1243240300002241: [111100100012010,100001021033204,103014201420321,100110414302000,100000001040200,100011204240002,103004211403213,110110111000001,114002100021033,200003202003412], + 322013114113424: [100100000422320,102100012002000,102233200213120,114200302333000,101113114202020,111100104100422,101000004222120,103241200114201,102212104041220,112001024003224], + 1400204401220400: [100232214222204,100040324331403,112104212010101,100001104201201,102300221002020,100002101020010,112010202000202,102033024010010,100004001000211,114230112330402], + 1020022211011041: [111104102242110,100002200410230,100044010200300,102000021444112,100003010413400,103334120114003,110112131124012,102330104110220,102102002004104,102113101342120], + 130104321111210: [103244320114100,100032011000241,102311011000014,101010300300110,112044414003133,112031121113040], + 1210400010032000: [102143124001400,100011011020440,101002121000111,114023314013200,100000201024213,114003422304142,111001404112102,102010201122000,114011042300202,101400031014311], + 322320233210422: [100003121032014,114000030020101,100003421042112,114240004110231,100030024102010], + 202023221104042: [102101324130010,102140000212141,101440004042202,102424114020143,100100204101010,102114020210202,101200200302210,111141312211004,102020014003003,100020024212001], + 100212202241102: [102140411342420,103243024040441,110021014412440,102020004000301,101031101024100,112000210242204,102201022000411,114403014112210,100100224031000,103111001212300], + 112220201012110: [102002000221000,100011224100020,102110010202100,101104410330240,100001040413220,102140201410013,103220204033101,102101224000200,102100321340322,103023020120203], + 1001000230030403: [114200212322001,100401210020002,100402042200000,110001440041003,100010111022102,100220300410430,101402010301000,100000220111021,101024201114010,102412220200003], + 1200400421002402: [112001312001002,114013314033010,103044111423021,111301002202012,102010010220020,101000021142411,102000140242401,101014101111340,110020301121011,110234044402320], + 1002102000030214: [111103240020200,110022201100020,100141214304000,101430001012430,100011204100020,102410220200004,102100211340043,103443104001332,112100311104022], + 112401003010120: [102120001343001,100112004101222,100030001041404,101440420301210,103043011400000,102100021410201,100004231022202,114100210002313,112002002000201,110140010032040], + 1042300202221004: [112032040234431,101020004000000,101004310324302,100120040400011,100214044220201,110410002020200,110100200400200,100124021201021,100200111001432,100200044121414], + 1001100010200123: [111423000022420,100102224234002,140102120200000,110400444243022,110131001002021,203201100012000,122001000320022,121104330112000], + 1004001122104010: [103110021442200,102132400232131,100114234102203,112221200410000,114023224010002,110020320412002,114400112311040,100104214302300,100300301002020,100422140030210], + 101042432400310: [112200004010400,102011121102202], + 1101020311341010: [114220040000201,111040032200021,100404400013222,110012130410040,102241044033231,112201010203210,100000214310412,103042320101230,103004004001222,112410040200202], + 130200001130230: [104100012102004,110021232000021,100401241014100,110301322104142,100001140000010,102420020204200,110033002000020,110343014421300,102100110230303,110302222022010], + 1121211032002001: [102001000212142,114121000002140,114020002303212,102303110220130,102223231121242,102103132002023,100024121030022,100124120011100,100020004300123,114003004031430], + 131001204134010: [402000401204030,114124020222032,100140201000222,110110000004210,101400010303002,104200202141001,130030220200012,112200110000221,1321002023100013,1022004103234130], + 1102210040114000: [101444024041143,114121002310100,103020001400040,101023020301100,110200332041001,114004020010203,102100221341001,100040004304002,103204321414213,100012214302010], + 1101121321400020: [110104112010103,111102004100101,100122004300410,102202414041044,102000104012232,102021100220101,114443330001442,100230120001003,112042110220004,112203221102231], + 1010024100204040: [111030212113431,102001111011201,110044320441241,102233034000002,110410122010102,101122404022022,110311110410340,112101202012010,114240004000000,102300104110220], + 1102003334203204: [100143114304004,100100101041214,100101201003011,103101000121031,114004012302010,103101024001202,102200300234001,110433104224034,114214012341203,100220011004202], + 241020003101021: [102100012000020,101031201001231,102000010202042,103012240110400,110202421203200,103012220110230,102101320312141,100120421004010,112230124010202,110002401320100], + 1014010040004114: [110104231221040,100102000010243,112410034040040,103101000100022,103000300120001,112300042020334,110001212010040,112112122012022,112030010222033,112003120220010], + 133012010030010: [111041004113300,100011144312020,103110120210013,100020221040231,1012220402104110,103012004034001,102001410221023,101010111034000,101020224001010,103021224040441], + 124021130240230: [102203011120021,100401140034220,102103122004211,103022230124332,101242004043300,102102131340404,102420041111041,112004312310301,100040121030000,102000404003020], + 112203012002212: [100200004301323,110010030440201,110041002130210,110020004414024,114340312301134,100031220121003,114310242320310,101100001102230,114302102300200,111042012220110], + 100200213010000: [101233021020110,101300120313040,101102024000200,100021031221022,112032021110403,100210104220004,100010314203131,110011022120011,101000101001021,100241330432204], + 1101100102101012: [110303120102044,101022040322021,102042100242012,110201310010120,102100201400021,101113031012041,114413012313200,111234024134400,102011011131431,100021420122102], + 1032103100013002: [101000104002203,100000121024021,102101104000212,110243310101220,102002304010024,112101002304200,100000130122022,112002002310420,101300040312022,101424020300230], + 1030001004000220: [102010040210212,104400301202200,140230300211231,100030010000110], + 1112102112340041: [101030001001022,102030001412241,101001204010220,100114230020141,102302141002440,111320210000113,103204101404121,101412210330002,102100020210143,100142120100230], + 1002312203011014: [100114234102203,110020320412002,100231124320130,103040424010400,112203010200014,114400444140020,114203004113000,101141111100022,100000404100021,103132221442102], + 1120042002003200: [100001404102020], + 1400021120440312: [102210020240030,121401221221000,110020000010044,110111044402003,114300410001304,110021011310043,1010030200302021], + 110114000410013: [100020220420321,100120004300002,101000310140030,110302010102310], + 1113210300210202: [112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,101002024000400,102202031002304,102240231110222], + 200000030001242: [110100030123401,100110014103210,102013130223020,101000011000041,104100302102030,103200030110000,110102202013213,110202120004000,110000242104040,114000444100400], + 133214410010320: [110034300021014,114400112314022,100112440013034,100041001211002,114200134110042,104104112101440,102300010242203,100204304122112,110011230001023,101233320302120], + 1043042210004200: [101001204211221,100231411002211,114240210000130,111240000001101,111202000003000,114100024001310,101043021124401,112030012300122,112012020241224,100000404100023], + 102240003042103: [112100124023402,101020044011003,100002414210010,102242204040102,100021014100124,100122040012210,101020104000001,103013200120113,101040000300110,110042141214302], + 1420034221310000: [111200140000402,100134120420201,101234100301031,100210304340400,102201032021231,111200332222140,111201314412204,102000200204141,103220100102140,103041130110112], + 130021040301112: [110001041213031,101110044200100,102411000200000,110414300030001,100030020011022,114100122342002,111202012222402,100010101020023,102000221442214,102040041320010], + 1101404040020132: [102042114010041,100020000022000,102223001120110,114010110022103,101443204042201,112113224002200,110020100120103,111320302200414,110212400000102,112002010201042], + 244021041420102: [102424204043100,100300211000020,101410401010030,103240001403000,103044004010022,100042034202031,112301032022414,102103100310300,102012014002001,112002014000112], + 321142410244003: [100222004320102,100110004103122,103020200141000,102414034040100,103031300144042,100120010421220,100000201041300,100000111034100,114011200003102,103132114002002], + 1220040220124203: [101011004212201,110032022002020,100214230430124,103031234000122,100400110020244,110103341120422,102044021101411,101100104002023,103230011412301,101042001021012], + 1022003012223042: [100034100023401,100320221002000,114203022320020,110140042002031,100140214101212,110120021300003,102220202001002,111200104424220,110141041304241,110012000002021], + 240113320121400: [110230231300100,102010424000101,100300121000420,100402431014100,100100001220400,101423100300002,103111300102020,112202012030100,110300011202224,100043300401302], + 1022200104244200: [102100304000010,101240100304114,102332320243001,110014231333243,110022114410310,114003040042312,110000040022323,110201400000100,110400204221003,112000000241102], + 110443022100300: [112100124023402,101020044011003,100002414210010,102010042000041,102242204040102,102042411104200,102321410240300,100021014100124,100130244302034,100122040012210], + 1032001114400430: [103342021400021,100102004300104,101020004011302,103004011400313,102300021103201,110010140011021,120131201313314,100121020100210,110002340022120,110030012103030], + 1003020021101200: [114003212210013,110302012103114,103023101400002,110010120440200,110024140022040,110100034200300,100401201010220,102100204000234,100211120140002,102043221012112], + 110100001021130: [103044010120003,100142011022211,101000401032212,103133031440020,100110021040020,102300121000004,114000242303001,102021111411014,103003101400121,114210002324000], + 1200011003200002: [110012000141104,140300020110000,100003301030120,100101004230030,103044004034040,102412140201410,114034000012210,100341231000131,102200414042021,102021112004011], + 1022130000304402: [102010040210212,111120432100010,102012201103000,113223002430413,140230300211231,103010140000114,111113002242010,103122200123301,114021034100241,114231004000010], + 100002020202212: [103301201402204,102401121113302,100021020124002,111201210000103,100101101010100,101320040302031,114010102300010,114042014014024,102321044112101,102014040242202], + 1132212040101333: [101342300314204,114104200220022,100021221021201,110001244204302,102010244010000,103003204011330,114200034110031,114423002314000,114040002210432,103314044033003], + 211003220221232: [100002100100210,102420424042020,100010001032223,114321002320001,103020031403100,102200401111200,102000430221040,114003104031111,100100000422320,100102020411200], + 101102000000000: [100031034311401,100023210021210,102100104000203,110200101200402,100000140100020,102021201410011,103211014030010,100034124101023,111010024402022,102400004021004], + 1010001101200102: [114031022302044,102031011441221,114103020221100,102012030213014,102003320200411,102002024000132,101044001032114,114430412322343,110100331003020,110040000022001], + 1402103200020020: [102000001322140,100002230124133,110030411202403,102001104000101,100042114342002,100432101014010,110311102100000,101000030310000,111020104123120,102314144114220], + 1120101011010012: [103210304032003,102130224131022,112011220222001,103110100210212,103214211400431,112432002020302,114220432322310,101242300302413,102140011343010,112004321121013], + 1043240403400231: [110232022123020,100002004303100,110130010102101,103140044032100,100010240101221,111000122201420,102100010213413,104134121240044,101024011034002,102000041101100], + 140201021040010: [103024100141200,102003304010020,102030004000432,112000000221030,114120122310211,101000001030232,110423144244320,102034421103014,111302110011020,100004001030201], + 1000432101204140: [102400014020002,102102144002200,114010014121300,101301414220012,110000410030114,103100220110400,102212431101040,110204031300403,110424110004001,100102224031002], + 240124203010001: [111000122201420,104134121240044,103000300124010,102430010202411,102100241341002,102414000204201,100100001040011,100002221040242,100001301020220,103000120100410], + 100024432022020: [100001004104043,101200000304000,102220011110041,112014402034232,114222422332100,102000000211031,102110000210220,114333212323001,111303034134331,103143121442031], + 100140020321111: [100413011000000,103234101420113,210330042103020,103202004031314,422202100011300,102021211440022,100024101020044,103140024002140,101004224000300,100111214302000], + 1120002012134340: [100022001030013,102010020244010,102100300210133,114444200000122,102100031340024,102233114003301,114401200002300,111000320303042,100024224200320,142014000003120], + 1000000100030420: [110202012100020,102303010241010,111342020011220,100314114322101,102230130203001,102021401324232,111222102243400,101004410311232,101201034010420,111220410010144], + 1100110211123100: [110013001010410,103042020144300,101200004202030,101100011200342,111310324120120,102000021021313,110100201320201,111010402100120], + 1412021002132222: [112113214020100,102010202004402,100000130013400,111130312211003,103224041400220,100001321032243,102104244000010,101001010300404,103340004020422,102410220200004], + 1140000100020010: [112020104001300,101400110300032,110032412204130,100101004300200,111032414402324,102424040202123,101120244000002,102110024001402,101300000340401,104240102023211], + 1000420040110202: [100030100410121], + 123304123124130: [101300300230001,140302100211100,100023404104311,120020400211102,120010201002204,100000011100100,120300312102002,100240221002021,112120100423020,110041140002200], + 301010323000012: [103001111221030,104101201240100,102301112004021,110000011012202,100201230412211,111010002110212,111121022221002,102000020241101,112311000204002,111112124402010], + 120133212323431: [102013010221140], + 142040121101031: [110222410000021,102030004002133,110002122002302,102300301000100,100224300411140,112211402032230,101140301101104,100441431010310,102040241133000,111023014402302], + 121300011104241: [102101222000102,100113004302233,101022204002023,100113040003021,103400311210111,110123012044100,110140211201422,101021304003002,112142010234322,111201012201003], + 1012120002321010: [100421231010141,110141420123113,110222121311112,100200041000012,110221022034121,110220200100234,103200121201441,102200420232102,111001204110001,111130022243041], + 1020000010240412: [100204210031132,100022444100030,103310104021204,102120214130021,101201000311021,101022044001032,100020204104010,110300112001013,100021000104412,114002222301143], + 102102400234012: [100200011001220,111202014132111,100003141022321,110201434240143,111030044110010,110041304201404,100040211022000,114000134102201,100420104301012,102110001401111], + 1000210211012130: [110300202021130,101300231002120,103400104001022,102212200313103,100240020430431,100202004320010,103021310002011,102101044000040,103010030100210,101011231024200], + 1124320210301021: [102022004012201,101010241003223,100000024210130,102034221103124,100014030200221,100020134212021,112001120220130,110204314402021,102102230203330,101001104003130], + 112021220414203: [102223111000042,100004420014012,102240210240022,102320200221110,101040401032021,114200004110030,111102324104110,102024124011010,102000324013042,100030124212213], + 1100310222233021: [101242011000124,100202340430142,114420242311240,110141001301302,101200200300310,101011000320010,102020004000040,114001202300211,102110201342301,102330131101200], + 104301202010341: [110320442100100,103022421400100,114422000000001,111201310013231,100002011024422,102141044002021,103021101430300,101011200324311,102100041341103,112400002021310], + 1412002220011020: [101020024212042,100041204212120,102113110210240,100410110420202,112423424042102,100320431000002,411200101402221,100120214230002,103204200103440,100210004104001], + 200021433001003: [112023400202302,101203440304221,100031001030010,110021202000201,100100304002210,110200100000200,101001000322100,114143412342040,100110141011200,110414101140240], + 1121022332003204: [102023210204300,100130101023140,100141314304233,110000004422320,100021304210300,101012341111024,100033104212020,103132204000234,100020001044140,102041014010103], + 304020020201411: [114000014014332,110420104221220,103041204010000,114030304122412,101014424224002,100023041030400,114040002210003,102014011102400,100400002200044,110004400412002], + 221000204222230: [110000121222112,112410112010214,101424410302410,102201011123104,114022004100430,102300000242022,112204022021221,110414130001220,100014001020030,110231000000102], + 240010043343201: [110400040000210,110044002100020,112010010241211,110020401212010,100300020140110,102041321123031,112100202011301,112124300200300,110002204204002,100200410430212], + 141100040031300: [103104401244021,112031202003020,104114400011000,140402143000011,100210134104040,110422001144121,110000031031240,102110224004010,100022024300010,101142424001012], + 1031440241024040: [100000001220044,102022200220022,102042031102112,102140114001021,102410111110002,100101041040330,102000100210400,114102302311211,114034400040402,103021004022022], + 1031002140030101: [100200400430003,114420102323300,110404122110112,110403010000304,114100040214000,101210021021243,102412044040011,100140024230240,101010200320244,102214000210013], + 113011120210100: [100114004100001,114102300004024,112102201102030,103222244003021,102420011111224,103001204002010,100340114211043,110232020002221,100033001220020,114233002340141], + 1000422421400200: [103301210142043,101110044200100,102411000200000,110414300030001,100030020011022,100400014321101,114100122342002,111202012222402,112012020230301,100010101020023], + 1104233101302044: [100044004100240,102011101321222,101121301100014,102010200213332,110010120042000,100210001002120,101000004211110,100402020013110,112004000213042,110113030403241], + 1010220030200112: [112141014003133,101442404002102,100020100002001,103203210100011,114301102300421,110100101240201,110200340000130,100021414314013,102000041101120,100313104014220], + 1120100000144413: [101221020011201,112310132020030,101101401020424,114030220011120,110020442001124,100011101011002,112002110240403,100100101220114,102040101121143,100010021211303], + 1023120012001201: [103211200100400,102112231020231,100022004300020,102320000240102,100042144200000,102030304001101,102000220220104,103020004011414,103310111402022,103110114000220], + 1102202003002400: [112222002021104,110121112012011,101400401012014,100213001002313,110020100004110,110200310002240,100211024101002,103140404001201,112100122300333,100201444322002], + 1120102020400021: [111011104401124,102224202023120,103440004000101,110212000110034,100010221030210,112100010233440,100212321001100,110421000003000,114200412322323,111200212220401], + 1101120040121004: [103124001420200,100220210034042,101210004011003,114434330000120,103224034003141,100204011000221,114412402323000,100000201032240,100204401004031,101240204232402], + 200020212112110: [100032041021210,110001041213031,102300324010203,110414300030001,102100142002204,100030020011022,102040011121100,111202012222402,111322234130000,102040041320010], + 1000120132204040: [102202000201220,102203011120021,101220024041000,114330432320002,112224012020000,100343241000240,112232102030022,101000424210014,102103122004211,103022230124332], + 201200400021141: [102000020223013,114040102301100,112121032014014,102310111001210,100020241043022,102100121341102,114100304142330,100301024310020,100130010101430,103112000210401], + 1100110310012002: [100201131000322,100240414222323,110002102230200,100210004030410,102304004110020,100003104302021,114342024030024,100312301000001,102103200312030,102200024024022], + 101021200224210: [111043000011003,100101004100023,110030000043100,102001211104244,102204004040030,110000104201012,100223021000014,110022001104214,114002020020121,111122322110210], + 1000202320314100: [102242201000222,101410044020102,101000011032120,114004202210130,100004210412101,102102042002001,102011014010000,101420031011004,102111001341321,100022204300002], + 123300133122402: [101013400302012,102021021031000,100000201120001], + 1002140001233123: [110332424431130,110421102023242,110011414201101,110020000440124,114400104140001,111120442100320,114312112320302,111001112202311,100212324104022,100230000410021], + 1140003043230212: [102422114040010,100022041001002,111240340004003,111101222244030,114032424122040,112011012004300,101021401003220,102020004001311,100101101010100,100301020420101], + 100100002201001: [100222004320102,100110004103122,102200130202201,103020200141000,102414034040100,100022304302043,103031300144042,100000111034100,103132114002002,100412200002013], + 1011400002021301: [110332121234200,102020424010200,103320000144300,112141102011002,112133134041003,100002220111210,110104411322230,100000100001342,114112014000241,110002001222020], + 222102331424320: [102001030224000,110224032120040,100240404100140,100340230424131,110001004210440,101202300303044,111002010001321,102042404001104,103213101421223,114020204020041], + 203043130041210: [112121214040022,102401221402002,102102011342302,102140200224200,114000402330220,101001244010120,101030224004130,114000010031201,100004020411201,110144100400420], + 1010113001103001: [100104341010424,103142210104020,111121004103434,112203001103411,100212024121000,100001001033200,102202014042012,100010001032200,100221110101420,102441030231300], + 1002102022031321: [1000110030001310,100231201410110,112213013124000,1121420100113022,1031104420000230,1001421031214242,110002402134100,101023220340003], + 103014002001100: [110130314400100,110310034424102,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241], + 1404110232102111: [112413224040101,100220100110400,101200031020230,102403004042342,101024001034211,111122004101222,114020040013100,114001012300002,102121100232012,114000222213021], + 100001000110041: [111200140000402,101234100301031,100210304340400,102201032021231,112020044000400,111200332222140,111201314412204,102000200204141,103220100102140,103041130110112], + 1012131220110000: [112004001122300,100222100402024,101301124222004,112204220200011,110013202120001,100230040410200,103210004031201,100030300422112,100033001230040,102002000242023], + 100100010103100: [110241024242442,110021312002040,111101042244210,110124002040002,110444010032242,104132420010010,100001041031013,114212102310100,110300112023012,110224200113042], + 131210221002110: [100332010141200,110231104241010,100020044100330,100400140020411,102020401120022,114021102203101,103040230101104,112004040221232,100101110400231,110010020014000], + 1010004112000030: [110033000022043,110100200030100,104412212102010,114102024123030,110132020031210,102340211000200,103044004034040,102300231000210,100020200102220,110414012023214], + 222224000111400: [102010000213110,114400204120131,114100012340011,100402340020201,114111200034000,111003002142001,103011104010114,100400300013102,103022121401123,111214012220421], + 1000002134030324: [114120030223400,100340100424220,101202014010412,102320230243132,100311004101130,342003122142040,100243404101011,100102001000010,102322124112422,110024102204001], + 120041002442220: [114423334140322,102200020202000,102201140211010,114000324101021,100020124304402,110000001044030,112010402310201,114011002303330,102201204030240,114012000020340], + 1003010040241110: [110212022124220,102130124000000,102010421413322,114002200000421,102113131343200,111210044101201,111100402200230,101020321002002,111123014100000,101042230304321], + 120030431041010: [100003104342121,100400414321103,110404201113410,110020034203040,100032304202003,101010231112144,111000100003022,100113020400211,100022030414220,103004004012230], + 1040040000103000: [114040300043111,110203111111000,114010030024204,102010201012014,102041204000002,102323204112320,100402201004014,100420404320101,102123414032304,112401014040034], + 203200042234321: [114102300004024,112102201102030,103222244003021,102420011111224,100020004300114,100000000413010,110232020002221,110010021200102,102101300311032,102013102002210], + 222201042020000: [110401004221204,111112000011222,100322444314002,101003301020022,100102431021300,100001030100030,112012004004000,112044204000441,103141100104002,104110100014103], + 211000020414014: [100120214301000,112013322301200,110400404221001,102100001021000,111121002100432,100210004220021,114104310000040,114202100004011,102010121100324,102000014012243], + 1103300343030342: [110103341120422,112122024023021,110042022001000,112001204001021,110104112012000,111101220010010,111020004404000], + 100314221020104: [100121230031032,112000431120410,103042024040104,102304104110001,102000200200301,100104211044110,114241222321321,114021002302020,102313204114304,114013124030022], + 1013142100012002: [102103001411402,114020012300033,102011201441000,103101000100000,100113410410314,110212424434423,110214002122002,102400024041204,101000014004024,110030021011003], + 120044110312333: [114120304000212,101211414040000,112000022310414,112010030221031,110012000000201,100001114011131,100102001220101,101021004000020,101010001141222,100221414100030], + 112231003012013: [102041020220100,114120204000410,100000001020000,102023031321010,102220020201230,114003104100012,114010214013020,112000224000141,102303021004001,102304010242101], + 330103201034211: [110101210013000,110212214400114,110012101102100,102102304001200,100101434332222,100000014100014,103001001421100,100001000100004,101014424011000,101230011021204], + 130131334222411: [114003212210013,110302012103114,103023101400002,110010120440200,110024140022040,110100034200300,100401201010220,102100204000234,100211120140002,1000023402103012], + 1112210032111001: [101021004214202,100011011020440,102114320203000,101011001103200,114001112300001,114023314013200,102040104000040,114022120040112,100000201024213,114002002300302], + 1120024002022013: [101042410301221,114201010001201,100030024300201,100020120101000,101041404002420,102220310200014,103231224012042,100040300102020,102400110230001,102101011342100], + 240012003010211: [112142301101040,101100000330120,101214440300301,101121100332142,112401314040311,102011004013000,111200122222334,102301024113440,100033230420102,111110004402021], + 1014400100010024: [100100300421022,101204121022310,100342220042002,101012121022204,114022002212232,100212220001141,110012102000311,112422000200003,102010004010020,100000114100022], + 211303120204401: [111201032220400,114203000004300,112401024044240,100022120412132,100000321031423,110322100104010,114043002302200,101222121020001,102120230230000,100032021041010], + 1000140140100030: [111200200000232,101200101021000,100101001011114,101430004040203,103122104002013,101020404210020,100001001021002,114200104001010,114040414014202,100000024301031], + 100100430440030: [101410211021400,100004214100234,103000011400001,114100012313002,110402410002000,102001011442200,100324200110130,100342120144000,102020001440011,100100031003220], + 100102020004010: [102111211401000,103302040111403,102020001440401,100030240102022,102004004001010,101222000300004,100302004321241,102111432004030,101232101021021,114100220004120], + 1041000003143012: [103112004030003,103100311424002,103040224000100,114323010000311], + 1100440001020001: [110102401201204,102400100230000,100212030414010,102031021441200,101200020303202,102020041321410,111340300010010,114120420223002,102013224003020,100002210201212], + 203000001200131: [102021241321003,103002001401403,103201300110101,110204002121413,100002001042304,102144020210132,100400000020403,103020010100321,110140004200100,100030001220222], + 1031020030010423: [101024200342211,100230404343341,102202000201212,112000134002211,114200000001130,100001401002220,112001021110124,111410110002320,100010020101230,100120001011321], + 100201301044400: [112324002020202,100120221021011,101401140300101,100030124210101,103220200100320,101030004004303,114000020034200,100010001040020,114203224111020,102003201440022], + 144040403114103: [110040022130003,100030430422242,101120014204000,110014300001402,100100014230110,110201004241002,101000131142230,100104044230000,114022024012213], + 102000001110022: [100140200020242,100004120021240,100131101201030,111201022223123,100400300134001,110001020030002,111421014442003,100100244002230,101010001000241,110030010140000], + 100003024400040: [102103114000024,100014011034234,100000324303120,100221200002204,101102120222000,400200234320200,101041200320322,100020400410010,110200320000000,121112122000000], + 110210422300200: [100003031030034,101001044211204,100000140100020,103001324000110,100002014200021,111010024402022,114000030014400,101013404000020], + 140031110310140: [112210010201431,103100024002220,103303000112122,114003100020203,100320104321221,104210021140401,100112101024230,102042030211303,101000400301224,102110214004300], + 110210242021141: [101032104014144,102120214004010,100022041030000,110100104403201,102142140313104,102000024044003,110410020403024,102214204040420,112412300200103,100010430202422], + 1403130023000010: [100042301001230,110002240134040,100020200023001,100040014310020,114000014100101,110031324200020,102100211124411,112202304002043,101110310331140,101000201000000], + 1040331203010000: [111103240020200,110022201100020,100141214304000,101430001012430,100011204100020,102100211340043,101422214042012,103443104001332,112100311104022], + 114312430124100: [114020000011320,100021314202402,103142211442311,100323140143012,100004411033203,101440400302320,101204004040140,102111021022024,114231324103240,100401041011000], + 300000021402122: [102211034013100,100044000201201,114241110000102,100010214313120,112040022002231,114324302302212,114401322310000,101110404001000,100212040003321,100000000101012], + 1123102221001201: [100003030003020,110010302000004,110410000104042,100014014203233,111422100034314,100102001013034,100001014100021,100000040413000,100001034310012,102030414003000], + 1010231200000222: [110200100002031,101420310301020,100020330100100,1002443410030003,111103224103001,102100141413100,102110021342213,112002310211210,100010031020102,100011401031000], + 202012120000200: [101002024223013,111000340012231,102000114002003,102103401440120,114300140000220,102110032004232,110040002120031,114213222324300,102322030240100,100402000020410], + 102300030411011: [114002104014300,102000311102212,102010004040000,102230130203001,112433112020200,112301312020123,103313404030100,101400201014000,102000201101332,102231041120104], + 1101212121001223: [110202012100020,102303010241010,111342020011220,100314114322101,102230130203001,102021401324232,111222102243400,101004410311232,101201034010420,111220410010144], + 1213210022420221: [102020010203200,110130201302200,103041021430301,114000402211404,101000100302003,110343042000030,111302204120210,102202031103300,100203211002212,114140022340203], + 1042420002220300: [111120230020122,102140000212141,114301000000002,112124310203104,100113324103000,102424114020143,102001000221124,102023021321020,114040204014042,100040401020413], + 201204220210010: [110241142024233,110441140102024,100413311002132,110210301200101,110400241240242,102200001002100,102210101121104,114443304123123,110023102103200,102400140230123], + 102300222300301: [100322000143001,102013021131042,102201000200312,112022110220022,100020100100100,102004021444000,110320002002201,113033001030411,100010024102311,102200304033030], + 1030011214001012: [100111011011011,100030040101021,114014112300100,114030034013101,102400124020001,100102224234101,101013004001421,103000014011004,102010321411140,100031120413224], + 1402031003014021: [100310304310342,100010041031020,100042400001023,102010020223010,112402000200101,100020201221000,114200014114313,101400201100022,101010020301243,111010130022401], + 1000003010012100: [110000002133140,101233341022410,114100012313002,102001011442200,101004202403121,100304320140012,100200034020100,103222001420142,100142104304130,110100000100000], + 101200410111314: [100422000031421,100002201031130,100102000010243,100024334203210,104301222102024,112300042020334,111244034102140,102104220213122,103012200100120,110402000100440], + 220120020013214: [114120430002002,114033300041020,100000100120300,100031021033010,114011404103142,114041002212302,100120004300001,100202121000302,100212024322044,114101024122320], + 1123204010400001: [102300111002202,100241001003002,111310004122000,101221000312044,102030300224002,112010022000304,110323142102300,104124002103241,101002211110002,102311031104220], + 1010221233021202: [103000004012003,112303041103203,102101024022111,102020231440400,114030304122412,102121104130242,100112011040312,102014011102400,100020410124020,101013200321014], + 1102314300203012: [102101324130010,102140000212141,102424114020143,102114020210202,114040204014042,101200200302210,102434211400021,100001300100302,102102001341000,114011012302220], + 201121134043002: [110303120102044,101022040322021,110201310010120,100400004303004,110002022030224,114413012313200,111234024134400,102011011131431,100204011002001,102013301320044], + 220200301004411: [102021401410001,114210410000401,102002410222340,103210214003143,100110000020111,114401000004202,100024104100032,103100024002220,103303000112122,102100014132110], + 1020342312020232: [102322014113341,101022104001221,100040201012040,110021422000000,101120030330110,112021004003303,110331012224112,114100222310230,100011120000004,114131002342130], + 1024030040200120: [110010000111020,102011041320000,114240012324120,100022010022031,102014140200013,101240110302200,100031204311023,101232001021020,100012121040101,111243002222100], + 1011010030224042: [111240220002100,110030344201413,101001014001021,102304244110431,100011000201002,100103224301304,114000100020200,102004230222000,102100322001021,102102100231000], + 1120401010212100: [100104024303320,114422004110130,112210132031001,102010310213001,102012030213014,114021114023402,100210004343102,102021221120401,110031200023240,114242312322020], + 201140001111221: [102001404012100,102122214131011,114223204100010,111041202200140,100023031000024,114021040010311,100020004101012,102402000201011,102311011000200,114220000000024], + 101320021031040: [102110230230004,102123040212103,102020034010140,103102010211110,100021000122000,112130002012100,112203420410100,102000011413043,100020404100041,101004210301301], + 100230012010002: [103031421401120,100414200432002,103421020124110,100404202201012,112000100221202,112422002024102,100111041000200,100200004102020,101121020320133,100300014213032], + 104102000001231: [110012031011302,100212030412303,111200104411001,101002104002020,100300304101302,102121200313040,100300021202320,111201004131300,111311434120141,100101041000013], + 100001412001010: [100100100422103,110020134410001,100300020142022,102101002004300,102043001021033,101210211022100,110421202110000,114100202200202,110004100002122,100100121010222], + 220423221121222: [100000104210240,101101200311102,112401402023020,103142104001331,100200204123011,103031120143010,110020211221100,100101130101111,103232020100412,112000210230234], + 203221200211100: [110300000011120,100000221020004,101213020304210,103221200100302,100424444303100,100031421024030,102204101123101,114021204031202,111011110004013,102103000214000], + 202202201101120: [112113214020100,103300344012201,102010202004402,100000130013400,111130312211003,103224041400220,100001321032243,101001010300404,100201104224131,103340004020422], + 1130443121020041: [102210100313100,102223111000042,102240210240022,102320200221110,101040401032021,114200004110030,101242004043300,111102324104110,102000324013042,100030124212213], + 1110042001101230: [100020020012200,102300111002202,102002114010040,100404010012404,102030300224002,112010022000304,100412414102410,100212341201044,114101042313041,103002024002220], + 111320000100042: [101100011102402,103102041440324,100002020122000,103001031403201,112110032304211,110033020003012,110042234410000,102424111401024,110000400030340,110020004203230], + 211132000231102: [100410200433034,114000100012241,112142210422404,102402404004240,134010224314220,120120103004400,100430114103130,110002202000200,100020314310022,101440120022100], + 1430000024201413: [100013204331410,101024000321043,101000001031042,110402040103431,101410101102110,114403334142212,100100004102234,112424004044002,110301330044403,100010100010030], + 200244430030204: [102334021001211,100001100411302,100000001024010,100111421040321,102023110221011,100000014202111,111310000002001,103131004000400,102000000222333,103020004011302], + 103120242040010: [100000304303100,112030202301321,110203004210000,101010140313340,110011002002402,111010200000330,111210000000103,111113002113030,112111012310412,103200321204100], + 1002120031224022: [111000100012002,111102010012102,111300030012334,112000021130124,114440430030032,114300232301422,100002124340103,100020211021110,102412140201410,114000010012402], + 1402010001001000: [102010221411043,101020004011302,114212100023341,111200112221320,102011200242200,102300021103201,114244100003024,102410101112322,102121041340000,110010140011021], + 113030102034301: [110104112010103,111102004100101,100122004300410,102202414041044,102140014001101,102000104012232,102021100220101,114443330001442,100230120001003,112042110220004], + 1100030004343100: [101233021020110,101300120313040,100021031221022,101200031021100,114210004110002,112032021110403,100210104220004,112201024001343,114402022310200,114421304140420], + 100040113302002: [114030110041300,103132424000410,112013102004422,100400220013232,110010002000100], + 1104444012104031: [112324002020202,100012400101400,111242212222022,102022411100012,100020100100300,100001210102104,101401140300101,101242000300000,103220200100320,101030004004303], + 303200040203400: [101042410301221,110432300102000,100102024100020,100011004102400,110040344210011,100003320401100,100020120101000,100003200020112,112143144020012,103231224012042], + 142100410211030: [110014002132100,104122202100000,103100304000131,110011212102422,100030100104111,100312021000201,102004010202104,114100024120001,100001122210110,102000110220120], + 122010302210402: [100413111001202,144041310003010,101201204010202,101000001002242,112342411130020,113013200130020,114122414000301,110201304401200,111032232230200,111003200003301], + 243114112111101: [102104201320013,100040404102010,111010144124143,110000022203101,103011414001001,1140000003002130,102102221400210,103000330141120,100021214103400,141112101002100], + 102100031100120: [100003031030034,101001044211204,100000140100020,100002014200021,103211014030010,111010024402022,101013404000020], + 1014042233020300: [100002221021122,101404410301101,102122111412001,101000141110130,110001041100000,110311404430222,110103202210414,102030100200300,100000020002303,110004031201142], + 1140100032112103: [102002112041034,112401144042000,101222044204000,112430220200100,101004101230410,110003122001030,111100202220222,101202014042010,100123311000030,100210011224040], + 1004100120001021: [102211230244321,112121214040022,100004004100120,100041014210020,114204120210000,100000030100102,101012400320002,112002100233204,103303001400240,102200121300400], + 1001401100141010: [110011232100412,110020120040121,110000100022040,111021030042411,110100100031014,110131011000142,102401010202301,100201134320102,110000302122001,110202012020000], + 100030020401100: [101214104041040,110104231221040,102012204010044,103101000100022,100020141044111,114200000002420,110401440001204,100042110122000,101021021002110,100142224102102], + 1004233001320021: [100021304300200,100020020102201,102111400210040,102023001440404,101023014004000,100020010101201,110412042010210,100100214102200,102103000233434,101000001032020], + 220024422100202: [110200002111002,100201131000322,110141400010211,112002040210000,100020300000010,114030014101223,110002102230200,110223121301222,112441020201421,100013004114001], + 102030120020020: [100032041021210,110004301222000,110414300030001,100030020011022,111202012222402,102001301120112,102040041320010,103203401400132,103142111441040,110104002010100], + 1200211024001002: [102021241321003,103002001401403,103201300110101,110204002121413,100002001042304,102144020210132,110420040000002,101020011031033,110003040140004,100210030001420], + 100010220010313: [101012130310043,111303420012131,110141221322023,101422004042000,101243404044201,103002341221402,110010224213240,112012102004004,100000020204240,114423004144120], + 1144000400000102: [102100111101131,100134111222040,102242241113020,100202404324312,103311300141243,114100122321432,110410304221000,100202101001210,114313344030012,114020010022401], + 1000203400134202: [102110120202001,112100042301414,110102030023004,102120314034114,112330121130102,110002101101212,111100320023012,110341222103022,102200120230002,100042024300400], + 1030101404000102: [101032104014144,112102002010331,102120214004010,101132010333413,114114040222210,102140041342000,110222140404112,100022041030000,110040432100110,100402020024213], + 1000003440110220: [100041200010000,110024021040134,110301001232000,100220010002421,102001201443121,111210240010100,100202421000201,102430001110014,102002101410204,114401230002424], + 102000212410100: [102020404003432,102110240224014,103103004030401,110213022100021,101224321014333,102322001000202,100030114200201,102204321003224,102214011120002,100011310420210], + 132110220001012: [111011002200001,104000131220103,100001002213422,100003000004420,100033020410033,101002200300021,110020004414100,101232101020423,103243114031220,110112201000014], + 102012110001212: [100011444101344,111003100041003,100420241003104,100002100100004,100000031021034,102013011414120,101403044020210,100132004303034,100134004303010,112131021102320], + 100212404012020: [114400022321400,100100020410000,100030411042022,114304212302401,100031420002140,100000014201221,110200030001040,112022400231120,110002421122102,101004110300011], + 1101120402220004: [101022014222024,110100120400020,100401024300321,100000201022420,114030000030012,103000011403101,100000010202201,100111404302321,103243014020301,100012024210210], + 1000034403112000: [110120144200000,114022412330004,101200221022044,110241112020204,100002004104004,102100104002224,102100224000210,102020004000014,102310140240012,100014204201000], + 1000400422220130: [102340221000300,100220124221000,100402002201002,101011014002032,102104101122100,102423114022101,101131201110300,112002010221020,111012030020003,114200404001002], + 1003013000131344: [102400031401212,114013342210210,112430012022003,100102204230412,110141012040443,114420444142010,102200001300021,100000131232000,100001401222233,110200222120200], + 1023002142012124: [111304340002030,110102000401214,100100111044040,102024102020000,112003020220120,114022100010000,103400201200000,114021200012000,102120230212201,102040131440020], + 100013110300030: [100020314101112,100340121001230,100020314311220,101010221000033,102104010203421,100021034210010,112440204040000,114202122320234,101000004210200,100110014231114], + 102300011233241: [110300324420404,112400230202202], + 122431414104211: [100131424302300,102104004021010,112033000244420,111011242233002,114302044003120,102320001000230,110014210424201,100202234032222,101422404040210,101430020300303], + 200204412203200: [100142010410011,102041410242244,102101220214011,114000424102300,102323201000412,102212434110001,102141020210132,112102314020000,100000014200001,114010002304030], + 104023203101001: [110300000402020,100003034100001,102000010200014,102110402004000,102431400204010,102112042004203,114030100040000,100120431012000,100002024212102,112210204002124], + 102000001024012: [100012320001320,102000331120104,100232214222204,100040324331403,112104212010101,100001104201201,102300221002020,100002101020010,112010202000202,102033024010010], + 122021030002101: [100111141004000,100440221001232,114204122330314,101023321002102,100012030122000,101000131030300,100013001030230,103101004000424,100011201042003,103104310211412], + 100114100020010: [114200212322001,100401210020002,112210322040121,100402042200000,100010111022102,102000224000000,100002104302110,110030222130000,101022440300020,101402010301000], + 104314042204004: [102302440220001,100104400403240,100020111221020,110010122102321,110002322101200,102220124000003,101020201003002,100230300001042,100311334020020,112400022020023], + 1023042204100004: [110102401201204,100212030414010,101400004022210,102031021441200,101200020303202,102020041321410,111340300010010,102013224003020,100002210201212,103013020123142], + 1144300103320031: [102104101340301,110014010012200,110020334420200,103100020210002,100100004230402,102110304020201,110202420004101,102442400231201,103004000112020,100024004103100], + 221022141003020: [1010400230221020,103034010121101,111320012221132,102302144110440,114140004123122,102143202000400,111020002202333,101321311004010,102110241342210,114122302311011], + 1010004011140000: [100030324200410,101000001111200,102300404024300,102113200210140,100040041020102,102403031110014,114200020003431,114420142322140,101002200343110,100140004102001], + 1430010000201220: [110202012100020,102303010241010,102120231343224,111342020011220,100314114322101,102230130203001,102021401324232,111222102243400,101004410311232,101201034010420], + 1100230021000003: [101221422120021,103300121401234,100122200020013,100400320033201,110011402100202,102331104112002,100004130002301,110121112010004,102020131413423,114132002200241], + 200040000240113: [104111102100000,110000102100212,110130042014110,100100014100021,114423100002212,100011401040040,111121012212042,100001020002400,112320030202004,110012102130100], + 200310000000400: [103201411402002,110022000023010,114020302300110,111002100021022,102302120210122,114100032320203,100400300013000,112041210224114,101012000320441,114124414000000], + 1123010401013302: [110401004221204,111112000011222,100322444314002,101003301020022,100102431021300,100001030100030,112012004004000,112044204000441,103141100104002,104110100014103], + 1222000410114014: [102200004120034,101000024002230,101422021012014,111001200003214,102100021410210,110012020021204,101001420312100,100022201044101,102200010204000,100031000413030], + 1030100224102031: [102301031000041,114210002340104,101013224010003,110110131010010,101012104214110,100400122200034,102031004000320,103040001400020,100104224300040,114110400002011], + 1123000244112000: [101000021010022,100022310120003,112004031122404,114341322301120,100040234212230,102210214110002,100020204103212,100000100104142,100200024301424,100101344302232], + 220122120201100: [100021044202120,103102420121202,111041104111423,100014030122210,112401000200410,110110120010014,102202210201312,102212444022430,102002000211004,102043100223200], + 1040104403024010: [100044301030400,111210044410020,111311402221430,111420230003130,100030100423022,112203301101120,111310000013103,101200000302112,100020001031123,100114010111402], + 100413221011014: [102302200210010,102340120222440,112202000411103,114003344011001,100002301021040,101014201030204,102411201112404,101203001010111,101000314000042,100031201030102], + 1010023010101424: [112112014020002,100004414100021,110112131124012,102113101342120,102130241400320,114402010000201,114204122330314,100004340100020,102241120242020,100002141021000], + 1021101030422441: [101301014221122,114110200212210,102102204022310,114040210022000,110012130410040,100104101200201,112201010203210,103042320101230,100020300102123,100120430411222], + 1412112020400144: [100400210010032,102000000220040,102011211321000,102124210200120,102014024011240,102330021000022,100000021221004,100030201220012,100142244232110,103144000112000], + 102401001121003: [101221121202421,100044011022224,111042022141200,102022031321021,100442220030040,102034010220333,103321230110010,103014000100413,110411200402042,102030000241013], + 1032014311200200: [112224111100141,111102214104403,100132004231230,100000030000001,110021340020022,101010001000320,110210020104031,101003204000300,100130334030100,100210301002021], + 1422230110104012: [102322014113341,101022104001221,110021422000000,101120030330110,110331012224112,101002200301130,100004431210220,103401034002022,100113211221220,102204000232030], + 241410140000441: [100422314300200,102141410230020,101134224001001,110020001224021,102321234111310,111122222240232,102340004011311,111134002210042,100013014300034,104132120011021], + 1001020004042102: [110100111221242,132344004001203,114303202300104,114020202201002,102100300233312,111021044400403,102203210201342,111001320002031,101000030312102,114000424010214], + 224002231100213: [101123210321002,101003010340102,100022024212302,114104002204400,110001010130320,103000001404112,103013331403110,102242114032121,111001442231001,100040000401432], + 130010421404001: [100000200202012,114404010003320,100013200412401,100141011011032,100010021034000,103132004002020,100000241000002,100000401002031,114030412303102,100430000030122], + 141000021431412: [100000241033100,114100032340001,102101011400100,102300011002030,100120220000101,102001004000210,100014100420220,102042404432411,1411201002002040,113120400001003], + 1041011020000020: [110201320000011,110200114241402,112214002024310,102000331322102,100302024101020,110020232003003,101020024001110,101241000301002,114021202300123,103000014002000], + 101011111204224: [112004202302034,103300004021200,102122214131011,100023031000024,114210400000112,103230134011412,102021021101204,100231020102202,101000134220400,114204204110401], + 134202231002444: [100122004300410,102000104012232,112400202020003,102000224000011,101212040303123,100021021000101,104240010040022,100011124202310,100030300124130,100001100013110], + 120101020222413: [110120144200000,114022412330004,101200221022044,110241112020204,100002004104004,102310140240012,100014204201000,102103321411004,100400001001300,114113000004012], + 1022002022230003: [110320202023400,111431110000042,100302141003012,102004441124110,103303201400021,114101420030202,114421242204443,100000301221024,101224322120022,110104422010121], + 1001021022014111: [111301240010310,101300400310002,102400014040241,101120321040104,100303101000021,111001212232021,110002300420010,102202110230404,112004031112020,100240011003010], + 221021003242220: [103030411422014,103043334040203,110422201312402,102120131401230,102412044040011,110200302024000,113130020101411,102041210224224,112200030203124,102004020224404], + 300344100042003: [103044301431001,102101142002021,102010220220022,103211001412040,101004114210003,102202030203203,102213241100111,100022202042210,100402022200030,100201010430000], + 110100000110224: [100003141040411,101021120323020,114111200034310,102001111412134,101032201032000,102220314010103,112212002031124,112201200414124,100102200102000,100101001013000], + 203210011000224: [102300041004010,103000140101310,112400104044001,102310204023400,114401010001000,110402112220024,114002310021310,100021401020000,100203310430032,110103011141230], + 101122034010202: [100201310000404,111110000001400,110213012040120,104124200021020,103100334030202,102434204022012,111204244100232,100130020020401,111301130002040,102211014034100], + 121300412002000: [114000040010421,112002010220004,103001131403322,102320001000040,102000034013222,102120004134001,102030021100041,103000114012310,103210214042004,114210010022002], + 103034002010024: [101114101012020,102041111020030,110022001201023,103101124003110,110002001231100,103001101403020,101304320302121,103110034001104,102010010200000,110000001321010], + 1402210030020210: [110400022010030,100214121000000,102130411411444,110202204213200,110002131200133,102412241111002,100424104302020,114142102344221,103210014003000,100021300411033], + 1421222110441200: [102301401002404,100232214222204,102012004010000,100040324331403,112104212010101,100001104201201,102300221002020,100002101020010,112010202000202,102033024010010], + 1044000213212102: [114423100001142,100040211022010,100110041021042,110202020004210,102204001123002,102311121001300,114120100220202,102022001130220,101311411021202,100002004240244], + 1100102114320002: [103004301434100,111322432204020,100003300001101,112120202314224,111321102010100,110141204400012,100010011202403,110102020032300,123000123110000,110030014422103], + 100200000032003: [100012400101400,111242212222022,100020100100300,101401140300101,101242000300000,114102404120000,102004021442313,100121211012110,102221220204211,100140304103400], + 320032031014103: [114124404100121,102010200213210,111010002230001,103141010210001,110001010440034,101023111024020,100400400010133,103040204030013,103210004020020,110303202101031], + 1034001210121010: [100102101000203,100001021030011,102231301122300,100021030100001,103230040101112,102001004000100,100013204210001,111121104100004,100010041032043,102321021000142], + 100111234400011: [114000044020204,102320000221020,110142020400012,103131420221204,102120141343312,114321114032200,100142011022211,114230344103210,100030020104423,100102011010000], + 302044400024400: [110041030411301,110001041213031,103301210142043,100002024200142,101110044200100,102411000200000,100400014321101,114100122342002,100010101020023,110033041200104], + 1434220011212031: [114020420040020,102103401140000], + 110000211003131: [114121100220011,102010021321412,102400204001110,111034332202000,114020122300100,111010004111121,111214202212323,110102021120400,103304401402003,112002032003101], + 100001201014102: [111000232113233,100200013102111,100303404100220,131431104100201,101004044212020,123030423110002,102201121303321,101000020340002,110411102112101,103040040100020], + 1212200412000424: [101204021022220,102100031320041,112141102011002,112133134041003,100000100001342,112102100202040,114112014000241,110002001222020,100020204312204,110200111304014], + 130022034002403: [102110000203003,100411400030100,102120221120200,114002010040032,100400012201120,110311011330111,102020022000021,102000114010020,102102000312101,100220204342200], + 140312100301010: [100020004313034,101400120320033,110430030000041,102140411342420,102020004000301,114114204001401,101042214000121,102000121102220,100014300000200,100210130430132], + 112403301042104: [112224111100141,100040134340044,103030411422014,103043334040203,110422201312402,102120131401230,110302011332024,110200302024000,110210020104031,102041210224224], + 1131012304201002: [110131142010001,100002431220022,102100204000022,100312200422101,101020301032322,112002320232203,100310020043043,102211200240102,110004031201104,111010020020434], + 1000031120010024: [100400002201113,102420424042020,100010001032223,102111024000402,114321002320001,102001011100100,114402104142102,102311120222404,114020404020132,101220111023331], + 1004010111024112: [102102031320011,100041140201301,102140041342420,102140021410400,103011100120201,102002030240400,100000120202410,102300004110122,102202334040220,101001100320224], + 1031320101004220: [114213002340022,114400210002021,114201402332241,144200203310100,114211030021301,114030214020000,100044001020100,114022000013011,100001241021321,111232232222210], + 231000002000301: [101001040340004,101013004002011,101300011002044,112022334022101,101011324004222,103210241422022,114411312312124,103240001403000,102202204040220,102121010212140], + 1042201120000101: [100220100110400,102403004042342,101024001034211,111122004101222,114020040013100,114000222213021,100000020401302,102103214000210,111001100020413,111301204111233], + 1404202021310400: [103110020210000,103001010101001,100022141030334,111020142144200,102303001102431,100141334301022,101420200304000,100221111000020,114024102212214,102102000212010], + 130200230200413: [111302204133040,110300000011120,100000221020004,101213020304210,111020010022310,114011302300101,102420021400002,103221200100302,100424444303100,102201000201101], + 112343234002101: [110400014223001,102040404010111,101021014224121,111301000000031,103020200123211,112040222311040,114230330212000,102204404111433,100420320030100,114040214101433], + 100010300103030: [103301244010210,100101031041022,100000240003101,100041234101100,103001220100000,114100000031020,102401024020221,111231012242301,103240404032240,114444004140210], + 100031200000201: [110000322130121,101023001002020,111300222202234,100200001210021,103204230111030,104130020011020,101114422122000,102001314013400,114110414140400,114013214010111], + 132120024321401: [103001024002110,110100012120201,110020204200342,114411200031024,100431200032321,103022034000034,103303031402100,100004214301320,110302004430024,102023301101100], + 1411211020410042: [103202134021411,102321011102100,102104004000123,100330104310102,101101000331232,103120234000102,114030310030022,100112301021402,114011004123232,114402022314101], + 100130113001011: [100030231000344,112311011101001,110100124402042,102120404134413,101100200330040,110040212000010,114102124000200,110211202030440,114440012312003,100000001024104], + 1022301021301303: [100210014322020,114010224101022,102100220210000,100230410112111,100030131042200,101203004042010,114221000210214,101410044041001,102343022000042,1144030041011004], + 1101004202110100: [102111342001302,100000000413211,102322001000202,100021031020121,102011220212320,100011310420210,100001104100010,110130224402011,112400010200232,112030302300102], + 1422200102201221: [112230122030224,100110130000123,100200201213011,102030000221134,100210304340400,102201032021231,100010020003310,101042204010110,102000200204141,100022024300010], + 1003202010101100: [101044120322004,114020204101200,102304021004012,100013031024000,102012014002001,112302412022221,100140014100401,103120021441003,102311441100020,102310010133100], + 123410031001034: [102302211004320,102043340202001], + 120103000222300: [130303204002004,114120242312002,102110201402002,123102202010320,114100422341111,103102104003010,102103130200001,121133013031103,110300222020112,101112240323103], + 1101001210301000: [110202012100020,102000311102212,102303010241010,102230130203001,102021401324232,111222102243400,101004410311232,101201034010420,111220410010144,100001221021031], + 1000211000121100: [114000034010043,1040014000334201,110220210110004,110221401304401,101310000020110,102220000230020,100111204004442,110420001101321,100212211003002], + 110101010200040: [102401004021010,102124004023202,110002100012000,100001104210032,114240102322101,110033301230100,110200202122114,100001100400202,102100304000112,101021344000433], + 1410320003040204: [110013202003320,101031241000010,102120231343224,110030332100203,100314114322101,114404232310120,103100034001310,114002202210331,100031301020100,110111032140220], + 1020002221310220: [100021214313034,102121111023020,110000212134440,101020134210001,103010020012322,1341322100304120,103002020124010,102120010221204,1000210011101210,124000002040110], + 1001022200103211: [102123140310122,110101214402023,110400014224001,111000144410222,100040001022000,112204022020043,112110112300112,100410124102101,110222241300101,103222120100140], + 1103022300121220: [103034010121101,100002301021040,101440004042202,101014201030204,102422411113113,114412010002302,100021420200400,103100201424200,111141312211004,100341044310403], + 100400020110201: [102302014010000,102342324111110,102000344002023,110000010440200,112212000423203,100402140022003,112313001130400,100400100020012,112110030200020,101002004004022], + 1002000303000110: [101001111020310,110011234213300,111000000043030,103120100104000,114121104000220,100011004201102,110011021320030,112002101120233,141002100010000,101200120302000], + 141030210010400: [101200204040424,100120200002330,110014000112012,111224024130401,101042021021000,102010211202301,102201211300230,101202020304010,110010002000212,103014410104041], + 1122002230110012: [111311002203000,110101114200020,100332111004200,101033220300404,101440410300202,110013002101010,114401020031002,114020204104030,103243024023000,103232031411102], + 310021210012441: [100000304340012,110404211211000,114120004000010,114011012210001,101301101004120,112120042011000,112011300220120,101202204232022,103230021411101,100020200100120], + 1020032201102134: [100020121020300,111110010022310,100240010430203,103432001210300,112440134041000,100210240013000,110401214242400,101044214042221,100033201031241,110010114210202], + 101424120000440: [103240411403020,100020101031131,101010000323030,100043420411130,103310220113140,102010124004041,114200202330330,103101101440200,112002201122121,100000101031020], + 1134401304200003: [103210304032003,103214211400431,102140011343010,100033210124132,100222020403200,112140010220300,111300002201131,100302104011002,102242040212122,100003020421240], + 230100000320020: [100034204311021,101121024024120,100102204231301,112201104011200,110003101312402,110341024422102,111031030040220,110024120430323,101403200302022,111400102104003], + 1000402040020200: [100202221212300,101001204211221,110004022000404,114240210000130,111240000001101,110010012102144,101020200301303,112000111120040,101120204202002,112030012300122], + 100100241002012: [110131441300210,103024014030000,103002204002420,110211112020002,114030100042110,111000024110032,111012030010120,103401411211122,103423034002121,111022144120001], + 1120230201140020: [114021000012031,122000430101030,100311000141022,114210202322020,102001101130200,124210120032121,100314020103003,121412220023000,142200042211002,100124230011120], + 1100000000031100: [114031022302044,102012030213014,102003320200411,102002024000132,112440114040203,100401001011010,110100331003020,110031200023240,101114000330410,110040000022001], + 242423020001001: [101220014012231,102010130231400,101010311003410,112210132031001,100020424214024,103422430124013,101000140310132], + 1200032202204000: [101032111230411,103010110120020,110100032122000,101020210301131,110304002000013,110200001314040], + 1211104214400310: [100403200010022,112003011123014,100000004310100,100013031002413,110020012001003,102212004013002,101101004204000,100221011202004,110020110040001,100020011031110], + 104202031141140: [112230002030102], + 100021403300304: [112120200204001,100030024301424,100024234202001,100020044201000,112102010201010,112402010201300,110032224422403,102102001342202,103244440103211,101340424220200], + 1101120311020442: [111203102223243,114311400000224,100040101001132,102113232001100,101110044000400,102102021002000,100303111202002,100101021021101,112001010242211,101411044021403], + 1002000110032000: [102002000221000,100011224100020,102242130202110,102001111412134,102110010202100,101104410330240,100001040413220,102140201410013,103220204033101,114010000010110], + 204222104004002: [102133011413110,111001200041102,114022424102243,101223020300040,102034324000220,101230020303000,111340130010314,110200422121211,110214220002020,112220414010040], + 100020000100220: [111104004400200,101001111020310,114002102301424,112222002031003,103141324004100,100020004200210,100010030104002,100011004201102,100234120400143,102300010241302], + 1134040411001100: [100202030140400,101024130300401,100110201040011,142011423130201,102000201102031,114031212300003,110004022101020,111001122224141,114224400021312,100001010404000], + 112003222001110: [102100120214000,103100004000304,102201140211010,100042121034200,110112402141330,100210001001303,101001144012310,102140030210121,101003120304130,110000001044030], + 220210040234101: [101000141031222,100012424200031,103001331400021,102043120222040,114023024101231,102002031130220,102101041341001,114241202320300,100010001040020,112431402022004], + 202421000043010: [114020202300410,102140201343122,100121100402000,241220023100031,123010242104441,102301024113000,100000411233303,110204420000422,100103414042003,102030014012023], + 120023324040003: [102011201101012,102300304110030,114412000003141,114120430002002,103020041420212,100112011040011,114033300041020,101201220300012,100401024300321,100000100120300], + 301111300000021: [402000401204030,114124020222032,100140201000222,110110000004210,101400010303002,104200202141001,130030220200012,112200110000221,1321002023100013,1103040030102440], + 210004100000043: [101010201030113,114012012300010,100302000140001,101000004003224,100241224311010,102001340200322,102021014004211,100000211030342,100000010100100,100210021000032], + 1221012400400000: [112413224040101,100220100110400,101200031020230,102403004042342,101024001034211,111122004101222,114020040013100,114001012300002,102121100232012,114000222213021], + 1103001200101014: [103102011422101,114300022300010,102011424013030,102201102000000,103012240110400,103012220110230,100120421004010,112230124010202,112220430200204,114201304004220], + 101202000100402: [103340041403223,112002110220340,102002220221002,114100234004010,100030410102000,100000221020014,102101010210022,102003224000022,100010031222001,103001114001210], + 1001200402413320: [100400224300040,110040102001121,110310304430141,110201002043201,102140210230000,101001004012413,102024244002012,114231014000020,103321024020142,102011111414201], + 121122022030420: [100023421041402,101010224000130,101144134001102,103002144042123,110012220002021,102304204110040,100210020410010,101000414002041,114034422302101,110421104242000], + 202321040302201: [112020042344001,100241000430420,110004302120001,100221201210110,102110104000020,103242001202412,114042110040100,112001104000332,103041200100301,110002201322320], + 101032030403423: [110020102000133,100000204342022,100001020012120,102101220213001,101441101010020,100001214303000,111202322222023,100002004342004,100200100401130,100123010012402], + 1113100022001200: [114000024100022,101020030332430,101022004214304,101001231032003,101010000323030,101001020322010,114112244122013,103310220113140,100043041020120,114200202330330], + 1100201000000201: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 1440102343010102: [114014224011404,110012302001040,101002021141330,112202012021413,100102131200140,110330000400230,110001201014403,112231201102041,111201000001101,110222144212143], + 120220202412000: [110130302012020,100000211021004,102411134020204,114032200030021,102000000224012,110210120000001,101000120303020,102000001133312,100402000020413,100011044210004], + 1104004003104414: [103101200221334,114021000012310,110041001300210,100400414300130,100400231000200,110332030011233,114000210010231,101000100340001,101300240310420,101000344223010], + 220202021004102: [110202004211120,110223224433004,110023342101220,110341010044330,102031144010424,111212114131222,102223400201104,102342120222031,102221010201113,111012030022123], + 1040030110002100: [110141201302122,100023001222000,101002124002220,140300020110000,100003301030120,100101004230030,103044004034040,102103012004030,114034000012210,101044004000132], + 1001222210340120: [100001130001003,102032031440302,103102104000031,110201134243240,111100044100001,102204004042041,110120144204004,103001201221020,102101002004300,102012014000133], + 1004002044003121: [110213100122010,110213001300231,112120222020002,102130100222100,110200204432001,102020411123201,103024041421002,102030004010204,102400321403102,114100214102211], + 1231203124221410: [100011011020440,101011001103200,101002121000111,114023314013200,102040104000040,114022120040112,100000201024213,102110230200201,112043010243000,114440124140143], + 1010020041101200: [102100001411312,114041010012000,100103214302031,112000132402200,103134244000000,114022210020000,114101022332103,110200014242110,101011344000022,110232044241140], + 111203000101320: [100201310000404,103100334030202,102434204022012,100130020020401,102211014034100,111000222232122,114002104100010,102301024020102,100002011040201,102102110231403], + 1041001113010003: [110200002031302,102040021121030,100000204130001,100412441010422,101010200312020,101040204210210,102300310220121,110000201230100,102004014011022,100240201003034], + 1033324002112000: [102100200231031,103241201200324,100240000430003,110030331010011,102121421141101,111020400021120,103402204002200,101024121032030,114003022330324,102022204000001], + 1031044004100010: [114201204111222,100104001041200,103300004021200,102122214131011,100023031000024,114210400000112,103230134011412,100012004101221,114122112202230,102021021101204], + 1001013310000131: [100011004341114,101230000302010,112241010203003,103000204042111,102203204044020,103010101412020,103223424020000,100122214230421,100120010002400,101030131140310], + 1003020110432022: [100141220000211,110042202002303,100320011001200,110002002200300,102002344013100,110443002010003,111200302214000], + 121240000022002: [103020031403100,102200401111200,114003104031111,114000044020204,114200302341234,103202430100244,102302331003300,102320000221020,110142020400012,112131004020212], + 101030000020023: [110130010102101,102000041101100,100042004301301,100000201032010,114010204101202,100041234101100,112204220200011,100000101024211,112021042003200,100211211002001], + 1103222304004311: [103030011404010,100013140102040,101002024212040,101011021020240,114121002204241,100102000022100,102140002001203,101013224000220,102310000240300,100223424120240], + 1002220130044112: [103100021421214,103312200112110,101000221031032,103402304003240,112402404024011,101112024024301,101231024010320,112001021122340,100340221201130,100030204100000], + 204400301220423: [110031034202003,100001211022312,111014004410102,100001124302440,101003004212410,101300021000320,114120014121314,114440122312030,102412300230420,114200434111420], + 100210201401102: [114024222212420,114201234002300,102234010200304,101220020300041,102440011400244,100314010143240,100012431020012,103042024012204,112210204003320,102200100204220], + 120044320332301: [100030220100110,100002114314022,111130202220102,102000100200100,102020400244030,103112100101020,114402102312001,100413131013301,110001102103432,112033300230131], + 330102144022312: [102230040200031,110122001010214,102101204000010,110022300420031,114230230000123,100222024320003,103323001400013,114013012300240,104121001242101,102024400223212], + 1212220200312040: [131402001003121,114420000001024,100304111000014,103300031403210,100022131043110,103422421110341,102010021413001,102040300202332,110010001011032,102024110400023], + 200230041040040: [110202210102120,114001004100003,100041014102004,110320022101120,102131421000411,101412030302001,102222021124112,114000040031021,102400001110113,100404201012020], + 1000401100010210: [111030022232010,100120204230441,102110004030022,100122200400044,110002200043410,114203222324004,101012400320103,112030312300010,110021012130120,100403410013000], + 1440132403010234: [110000322130121,101023001002020,111300222202234,100200001210021,103204230111030,104130020011020,101114422122000,102001314013400,114110414140400,111201100011141], + 301224100000000: [100200004301323,112401024044240,100031220121003,114302102300200,111042012220110,103312214033030,100030424312230,102410244043324,103001004013200,102002240222132], + 130002044043000: [102200024110104,102102030231013,100111120412201,100134224003032,110311100112142,103200301422221,101130020303010,110203034240000,103002214040200,112220030412041], + 1120224041231022: [100431024302303,100020010010020,110231211300200,112004020202021,110003001101020,104134010010001,101300011002200,100201441000001,110311020011020,100030204100110], + 1021210004312140: [100012320001320,102000331120104,114040300043111,110203111111000,102010201012014,102041204000002,102323204112320,100420404320101,102123414032304,110420220003321], + 1104002000311101: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 200212020030411: [102404004041224,102200041120220,103220010101140,101140014001001,114101002200223,1034110304101100,110021041330000,114321140000202,121102001120113,103322000111220], + 123004313111011: [110202400003213,114112014140000,100133004000124,112440104042121,114200124000134,100120204234213,100003011231420,103230231200010,100431031014023,102010204002000], + 1142103413304220: [100104024303320,102010310213001,103244320114100,100032011000241,102311011000014,101010300300110,112031121113040], + 1032010210030041: [110301402000211,114000014014332,103030201402004,102304340220231,110420104221220,103200004030020,110240214432004,102122141142000,103041204010000,114432234113040], + 212200030323230: [101030001001022,110230231300100,100300121000420,100402431014100,100100001220400,110330200400021,102100020210143,100030024303110,100142120100230,102220324011110], + 1211212212200042: [101302340312230,100400122201240,100011101222101,101000034000203,100200321200200,112044200243000,100002300421000,100202140430012,110200301210031,110000420020100], + 121101001104002: [110432300102000,100011004102400,102304000210204,110040344210011,100020120101000,100003200020112,101000100340001,101300240310420,103000300124010,100030301030114], + 313040240200001: [100002200103104,102040300241403,100431000032001,100202031002101,102103331400000,100204101210044,102021024004322,100121114230123,102102334000400,114323400212122], + 1110104012102222: [100024001040202,100003141040411,111110014101210,111344032200432,101002100301021,114121222311302,102100301341002,103002124000042,102011020220400,110024000410240], + 1130112340202231: [112113214020100,102010202004402,111130312211003,103224041400220,100001321032243,102104244000010,101001010300404,103340004020422,102410220200004,103113010102100], + 200310444140000: [111220202240410,102200020211042,110114002004014,100010114200031,102341041000204,101224110303300,110003020001402,100000144311102,110100200402003,114001000010302], + 1102211001200000: [110001332120300,102101211411000,110003000420200,110243234240200,110004014411012,112000120232022,102041220200010,100002320113100,112240200202201,110020321120011], + 1440031100120001: [103112004030003,103100311424002,103040224000100,114323010000311], + 121021001042233: [100004011220200,110024021040134,110301001232000,111210240010100,102400204022024,102430001110014,102002101410204,102000004001020,100011100412123,114401230002424], + 1411320012201101: [101001044211204,100031034311401,100023210021210,102100104000203,110200101200402,100000140100020,102021201410011,103211014030010,100034124101023,111010024402022], + 120101044000211: [110010334200041,110022004410312,100001024102001,110400011243102,114100120223101,102000401442010,321114010100340,100121041041101,102322101000200,101020041000102], + 1002000330321000: [110012231320200,101203001010000,141000211410012,100113300012420,110101322000312,103421314002310,102102010232420,100100001004210,103004000100014,102202421120032], + 211204302112402: [102002410222340,100110000020111,102100014132110,100002031021102,110232232034400,114000002300110,100024214100000,101013001000203,101040121003000,100104044100201], + 211000200240002: [110001202003004,114000122301411,102114101444001,100022121031020,102141010230201,100103240011013,100020210101002,100042420003120,102300220220432,101020120322020], + 130141101102212: [112342210200100,101021020331240,102131221410130,110031011310220,100020400003003,114100234000201], + 201020401210324: [102040431121110,102212000200124,100300310140241,100240134323001,102042000222002,100030010102102,103312241402001,101004200301002,102122412001012,100022001040322], + 1422301023203200: [113122211022230], + 1142000100001002: [101302134233230,100022001040322,100000130010033,101030404212000,114102224000201,100022021041122,100020001042002,100013011020311,100120041020012,102012204000242], + 1042301012221000: [100012404300402,114001310020304,101210321000020,102004021122000,102402011111020,114333400002202,102100024003022,112311301134110,100120001002143,110320222022322], + 1100022000200103: [101124304021340,114012040032014,101002044010000,102100234001041,114030000012340,110001000011400,101204001023030,111103402111200,100003030413032,112430032020021], + 220031222142300: [101002031030004,102301110242001,101002134010003,100021004312011,102040214012332,100111304332002,112020242313303,111004220040121,100132014003120,100240214100000], + 1003410220042303: [104441021202022], + 102000012443012: [114001000020102,101020040300010,100213001000212,100002004212420,102121014002022,100141404233000,114131002342130,101020001030204,100403122201202,102303304020122], + 102121040200010: [101020024001041,100200201000001,102100000210002,112224232044014,112002100240200,103032004012111,100001404100110,110131022014120,101213110310042,112000002000110], + 300032004140021: [104120011242011,114300000000002,110020002104100,110210014220001,102111400202120,111400214442024,111122200021102,112400034040002,101041100300001,100000020201032], + 1020100110003130: [114024024023000,110421102023242,112100200230014,110011414201101,110001000023414,103211404020312,111440120030122,110202002231020,100120400400010,114220432322310], + 1103204101211110: [102000001132113,102202310203222,100042001020203,102002320220202,114130210231020,100004410120102,101020104000040,111222214101043,114412142320040,102100044000000], + 130200124013021: [100020344302010,100002100000100,110030004200002,114100102340003,100100414230101,110134022013042,102110011142012,100120044000204,100001000000200,101034401033340], + 1423003021430230: [111240340004003,102021024000010,111101222244030,112011012004300,102300010242330,102000401120420,102004012043122,114011102210402,100120001014040,114300100000041], + 132000110004104: [112002110220340,114040210021100,102002220221002,114100234004010,100030410102000,112240334012440,102101010210022,100010031222001,110020200001031,100034021034000], + 310010030020223: [101001014001021,112210010201431,100103224301304,100410331002222,100032204311200,102022330212000,112004012000011,100031301020002,100320104321221,112123020420224], + 1421010011200001: [102002014000220,102203004042010,102410004024030,114402320000202,114014112302234,102012401001012,114112000004001,101004421020002,114003002301122,100110210033043], + 242332030024112: [103020031403100,114003104031111,101030301000221,102302331003300,102003111413120,100023101043203,112131004020212,100033001020140,114200122340300,114330420004101], + 102003031003010: [110020102000133,100000204342022,102101220213001,101302001001041,100123010012402,100210131002013,100124031002220,102240014031121,110310212100024,110420022110000], + 100221302020040: [103000004002012,100042100102211,102110030200120,100202140000111,114001032300011,100142044103021,101100010012423,100330020141212,101031010300013,100301010142004], + 210201040124301: [102230021122000,101004004213014,100121021011022,102003010240141,102242024041210,114022234100400,112210102030020,114130120222102,110000222130120,112032322004103], + 1020023401212202: [100121214300000,102123214020000,102022124012030,114002320022312], + 132103410002010: [110004020020022,114032412303041,114322024034312,100100244231020,102040010200101,102200434012013,112000301122111,102100201400122,102013120200110,102020130212402], + 230003400300422: [103023200124021,102141401342003,101012000300312,100110044231020,101000110324210,103001024010002,101010324003011,113020230142210,112440014042100,102300200240230], + 1000100030000402: [104310001300102,114021132202032,112012004004324,103001314001021,114122220031004,103040024041111,101004004213014,111124002211203,100121021011022,112034420220403], + 1041002220022202: [103001024002110,110100012120201,100010104312120,114411200031024,100431200032321,103022034000034,103303031402100,100004214301320,101000340000101,111203002221000], + 1112201221101002: [102441324022342,102142004001013,101213240301002,101041301000020,103220000104122,101401030302440,114240004002100,103000111403340,101404104022202,100000011233203], + 1000012011222401: [102000214001143,102142000224040,114000122300001,112133002010330,110103332012031,102000344000000,112201031104011,100001004200110,114010204022402,110201122110010], + 130100131014001: [100000121042240,102101201403410,114001002200014,102413124042401,112210400412120,102000320222120,114234304112011,110240221202310,102212311120042,103100241442411], + 110002020040310: [112411140200242,111201202221200,114323400212122,101001201000220,111123002210402,102414024024010,100011004203023,102022020220023,101010020304020,100010001043003], + 1002211040040300: [114000224021230,101300244224432,100100220411240,103022101431300,102110004020133,100224010432200,101120241102000,114131014004220,114014002300000,112120004043000], + 121122321030012: [102120231343224,114104144120120,102310011001022,102104001410213,100031214201041,103120210212230,100022221030000,102140201342100,102323034112101,114112000000211], + 130220302023000: [100010300121000,100001020100202,112342222022401,110002202000200,112044002313041,112202311102010,111411130210010,102221224040201,102111201141234,110021420430011], + 110210233003003: [103041220111410,101100202130022,102004201032002,114101012343012], + 112230141003000: [100024000110221,100110020031042,101301014221122,110422102110221,114220040000201,102102204022310,114130014001202,110010220103020,111004100022110,101002201140040], + 110111003000001: [101410411010012,100203011000010,102221104042021,110001040443212,102022014002413,111002134113102,100140021040220,110212320001324,1034200000211010,1340010113012333], + 1000010412223201: [114441040001202,114422000000123,100010330010200,110412000000421,110221004213100,101112314020004,101023300320033,102203221104401,103100020121000,102220104012021], + 130333010240140: [110120144200000,114022412330004,101200221022044,100103104302044,101041030320401,110241112020204,100002004104004,103130021444021,102100104002224,102100224000210], + 203011140201112: [100004001021111,100001010014420,100003000104203,102041410242244,102101220214011,114000424102300,114001214100103,102311110240101,102141020210132,112102314020000], + 1400222002221313: [101022014222024,102203344011410,102103430210003,100012014300120,102414014022212,100032000101014,103030104000102,111311002224001,100032134101100,112010024023002], + 120103001020314: [100010221022032,102404224041131,103301104024110,114024030042032,110024010110012,100000414342003,111143034100121,114040004104121,100031101041011,100001131020300], + 100010233130003: [102110230210000,101124201110410,101423221010210,102200021102420,103020201412410,101010211033312,114421302322203,100200401010040,102101010200120,100200001003310], + 1102304224013203: [110300221220031,110201220000032,100021214313034,122011001202102,202023004201110,114214202320312,101001021001033,100010001030022,102121111023020,110000212134440], + 310430313100220: [102300324010203,102100142002204,102040011121100,111322234130000,110113004402201,100030024303023,100001134100120,114023214101310,110301232000100,114110340004414], + 1111342001000204: [110301011320314,111004014402201,102100200002331,114311034034030,101340200340001,100001000001210,102200112000100,132303424001013,123320003100311,101041400311420], + 101004130040421: [110002412130400,112011010223100,110140304404000,112110001102104,101000011003140,110202022121042,110000121102001,112301031103203,110222431302410], + 1101003301200001: [103242420100012,110224044242243,101400004022112,100100210000011,102200000200201,103110020210000,102201430201310,100022141030334,103200211410311,110000320002401], + 1100220302311410: [102032000201000,111123230011010,102001114002202,1001213310010221,103210000102340,203114302220300,122112002001021,1100000001400421,1112220124040014,110202040110440], + 101100300300024: [102040431121110,101221020040220,114111100021420,102212000200124,100300310140241,100103104302044,101041030320401,102141212000200,102042000222002,101203121020430], + 122204310412010: [111304340002030,110102000401214,100100111044040,103140014002031,102024102020000,102224241110003,112003020220120,100043024210301,102014001130100,114022100010000], + 1040004001200222: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 1004112041012212: [114300200000110,102000021133001,102301434110030,102100301400242,101300340341000,100111341011011,102401001400103,114421030000000,100130200020214,101000011031133], + 124302130120210: [103000004002012,100002011042020,102110030200120,100301421002002,100202140000111,114001032300011,100240101000030,101003104212220,102302211002004,114030310012122], + 1040013000120120: [114213222330042,102403004020102,103303021404201,100020010420242,110001040133002,100020020411100,100011101000012,110440404220220,100022001043034,102430100201204], + 140100143012322: [110200411140130,110114120120100,103124210100201,111014200024034,102301002004242,112020014000340,110021404214210,101003014210212,100130220400031,100210024300001], + 211201002112204: [114444244144110,114201004110120,100412114304000,103001020120202,101000020302400,102021014012210,102244221114031,112400000200011,111101400011011,100101004301032], + 123420320314440: [110101210013000,100404121014002,101240220300022,103011431401300,110120020002304,100011000202214,110012101102100,102102304001200,100010040001210,102002020220000], + 104130221040413: [114200212322001,100000210100030,100401210020002,100402042200000,110001440041003,100203011004130,100010111022102,100220300410430,110101021201003,101402010301000], + 200033000100233: [103303001404000,101410021100102,100110004101000,102221204020110,100103121021000,102203204123112,112100020204342,100442041001211,101212310301011,102200312000014], + 1022202000342000: [102442024024214,102100330211131,100011014103012,100030220101040,101240021020011,100400020033003,100100110411000,112204130410100,103412114023431,101400004021230], + 100204031403310: [101421100301230,102130124130100,102022020204430,103214021400010,110100022010014,102000324011143,111110420014032,100003131040012,103004044010300,103144220102102], + 1001020013212113: [114022014010344,100103204102201,100021104314210,100023024300210,112000412001142,110020010042001,100001034302344,102113101023001,100020400102400,112020014000031], + 122123001322222: [102342214020012,100220024324023,100214104301120,104130011240303,102320234112041,112420030202242,110012021200100,100120221224010,110000200000133,100112024032033], + 1002323202100000: [103304014020032,100004110000301,114202424001100,114113004120221,111210402244301,102100011341140,1120022020242320,102320231000001,101122031100000,101211011012300], + 200020010004100: [100024140122042,111130032100003,102110044130102,101020424003002,101020130302240,114001104102144,110004030102043,110040000031242,111331014120444,110022002010102], + 1001102340011320: [102021001132040,110402420402001,110021021210300,110021232000021,110404000000012,102000101120123,110221022101104,100020311220412,110123004401121,102203031121210], + 1401330004220002: [110120144200000,101200221022044,110241112020204,100002004104004,102100224000210,114201104111034,102310140240012,100014204201000,102103321411004,114113000004012], + 1002320400132000: [110300120403013,110131002010202,101010010320020,101120101100112,102410124022400,102300424112201,101020004001002,100030031220030,100010100420004,100120300002212], + 101040043020110: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 1141010201442220: [101230114202200,100400000020230,112411140200242,101000034212001,111201202221200,102412001111203,102440400200230,111123002210402,100011004203023,103001241432010], + 1020302012421014: [102110141401203,100003021041343,102040034000131,110111200000000,100341001003013,102200011120011,110002341300120,101010011000121,101022140300332,110140412011321], + 204002110140322: [102010400202113,101033044211203,110111200000000,102200011120011,103102234003012,101010024011001,112100330410121,102121001142041,100023120012013,112214200222101], + 101134012000120: [110300324420404,112400230202202], + 204421121232032: [101041010324010,101000004210020,100032300010000,114140404123402,102130031410200,100010300414000,114310134003100,100004040120000,114011014014042,102040411132010], + 1122000200040320: [110031034202003,100001211022312,100001214303000,101420304041030,101000004214010,114120014121314,114440122312030,101012314212232,110042200411210,114001204100003], + 1020121441133031: [112221002043330,103214200103130,101011024213031,102230200204114,112030210211000,101210021000110,101000121021044,101032004214120,102100202001221,111214012221010], + 1040200220043020: [100011004340114,102002204002010,102101101140040,102000021444112,101012320320322,103100214001400,114231402333020,102121001343030,102102030210111,102311014112010], + 100400030221014: [102332320243001,101004204212040,102202014030001,102131341023330,114003040042312,100122014301301,111201200004040,101003204223410,112321041130330,102113100201211], + 203102001212031: [101022014222024,103114204002100,114230004110101,100001101033010,102142002000030,100000201022420,114000024101202,100100014302013,112020021120403,100002114104410], + 131041214120220: [114402020004242,102242304042410,112032012004300,101001034002001,101122414004224,102000201131020,1010120030012200,101024411001024,221104221024023,112220044014012], + 211320002000042: [101003040320032,102000401132401,100110314300212,110022302102330,112032314000320,114300110001212,101032401001100,112101204022303,110102020034012,103400021214112], + 1121104000200320: [114021412213020,110030002000422,103100014031411,110000300424304,100032121024110,100402431012022,111403100030130,102402330230011,102022400211311,110030400004330], + 1102130114123404: [102010011412143,102323124020210,110221030000000,114202222332202,100010024101400,112020220232032,101230034230201,112420102020304,103301011402200,110104104223210], + 100220021003024: [111000100012002,111102010012102,111300030012334,112000021130124,114440430030032,110011004420221,100020200102220,114300232301422,100002124340103,100020211021110], + 1103232022020200: [102401141113031,102304314110202,110210400002012,113032012204012,100204311000400,100403012200201,112002111121013,114211100001224,102112004004002,111011012142130], + 1000104010301402: [100300031003200,101023000340120,102310031100100,114002034102120,101020200302021,102021030221122,114020402303041,103000000104034,112004044022023,101010221002100], + 1401143300244402: [102022030202021,114000104100334,100000111040212,103322201402320,100112014300400,101320420300210,103010424023103,100400404322200,101232100300211,1000000000020010], + 131101211002002: [102023104002000,114010314101200,111114010020011,110304044431200,100001204302200,100310111001140,112122104040040,102103131122203,100000004204201,114002104011010], + 201400420001130: [100413111001202,101201204010202,112342411130020,110201304401200,102203320200340,101204000300001,112004421133402,112203224002121,103100000122400,112101220200431], + 1014002010101000: [114200212322001,100000210100030,100401210020002,100402042200000,110001440041003,100203011004130,100010111022102,100220300410430,110101021201003,101402010301000], + 1000102024410000: [102424204043100,100113220020101,114031000022030,100300211000020,101410401010030,114310200002400,103211220100010,101202201021310,103044004010022,114130020222342], + 1000012010013210: [102422114040010,102020004001311,100101101010100,114103212312012,102321044112101,100022024100041,114231212342200,100020011043020,100021231020200,114201112322020], + 1020023010022302: [100002031120341,113020001020004,100003044210040,103243401401133,110012212132410,101210014200430,110014011320012,110400022122040,101111010020120,100223400002001], + 120030002313204: [114402404141241,100200400430003,110212022133311,101041210311410,110022004211030,101210021021243,100140024230240,112230240412241,110000204203220,102214000210013], + 300210020000003: [100024000110221,100110020031042,101301014221122,110422102110221,102102204022310,114130014001202,110010220103020,111004100022110,101002201140040,103030040121410], + 110310000210213: [114110202310100,100112031000231,100203001000312,112034100224100,101101421100021,103400001200200,110331241332440,110120122010133,100210301001021,121030014300011], + 111101040102020: [102310324112030,100410130030232,103220101421001,121110020100002,100002104204000,140004230143221,144200400000000,103321202010002,101124344200400,102021220202100], + 130123330014210: [100020330100100,102110021342213,112002310211210,100010031020102,102440031411200,100023014340130,114214034100221,102200204021004,110012001100010,100041430100100], + 140004423000020: [101221414041100,103041020101400,111300402200003,114141024004011,110022341300320,101021244012200,103040000000212,103000001410123,110202221212123,101300004211000], + 100022210133110: [111000000010022,112110001103200,112044010213042,100400100013220,114300202300030,103401140121121,112100122010004,110010214201300,100112000400000,101041004000412], + 104021002242002: [103122020213112,100104010021241,114101100211240,103012011434022,101032010342004,114102102344110,114010002300003,100112110020301,100000004102124,102000034013222], + 223241001220000: [110241024242442,110124002040002,110444010032242,104132420010010,100001041031013,114212102310100,110300112023012,110224200113042,103203404020010,101000020301410], + 130042104003431: [100002201220230,110043000044000,110002420440214,113000010132312,102202020200142,100020224312010,100004204230430,101101301100110,111040400003000,100010111222000], + 104020001440042: [101020024212042,100041204212120,102113110210240,112423424042102,100320431000002,411200101402221,100120214230002,102440100200000,103204200103440,100210004104001], + 120000432013231: [112200224002440,100000311022110,100202004324201,102041020200401,111103214101012,104103012102410,103200100100303,114011204102241,102123001340111,102202004024001], + 110420210203120: [100440031001120,114203042330220,102020200223310,100020001041410,102032012000101,102102231400111,100032421040120,101004201001232,112102102302000,102141231343401], + 1004204100011420: [100430021001320,114042102330002,100014001041000,204020131034103,114113404003030,102310030240210,103214301421201,1000001214032041,102100204001030,102200400234000], + 110041110341222: [101001040340004,102424204043100,112022334022101,100300211000020,101410401010030,103210241422022,103240001403000,102202204040220,102121010212140,110020124200230], + 1012020002410120: [100040201012040,114100222310230,114131002342130,110002022003101,110224130002014,100403122201202,102303304020122,100310210142030,114132012200110,103011011410312], + 1042000021003221: [102343230224321,114201104111034,102310140240012,111130210020000,100141101044100,101022121001000,102102201340311,100001104301200,1001300002020110,102014204013110], + 132101034304010: [101214104041040,110104231221040,102012204010044,103101000100022,100020141044111,110401440001204,110204310112224,100042110122000,114400322311044,101021021002110], + 1031302000233240: [110401004221204,111112000011222,100322444314002,101003301020022,100001030100030,112012004004000,112044204000441,103141100104002,110341300400201,100000104210240], + 1011043202114020: [101230040301234,102303014024221,100010314103002,110310321232001,100100224304110,112000000211220,101020024210020,102000110221011,100022020412310,114103244123211], + 1000012200213001: [100212424322433,111142000011122,103020201401020,102000401132401,114022020042232,100200410434002,112130030422202,110002022130324,100221124121143,100414300433033], + 131003032313314: [100000121024021,110111041011032,110243310101220,100020010022143,100003014244002,102100311400022,101000004000400,114003102303200,100000044310330,100011000420231], + 124123001220000: [100003211020020,111000240044102,102300000220000,100011200100023,100010044213301,100330204322010,102111211401000,100122124300402,103031114000000,101233124010023], + 1141010002240001: [101003201002421,102034004000133,114440012312003,102112411140024,102113000210043,102114101120004,101010011034220,100421111011000,111232024102030,100020104104100], + 312200100100000: [110130010102101,111022412140224,100212034221414,100222100402024,100121301023030,100404000020000,100020224310403,100020424102200,101121401110420,100200001211010], + 130104120020410: [110030230041304,100043200201202,110102110122210,101240011000120,102020034010243,100140001040042,102111214004020,103212144000440,101422120334233,114243122320133], + 102020021202423: [100440000030040,100023101001004,102001014013004,102101000233302,103210210100210,101013101033100,101043004211000,112340340200112,100001000010010,100002121021340], + 121000042040044: [110202012100020,110013202003320,101031241000010,102120231343224,111342020011220,110030332100203,100314114322101,114404232310120,103100034001310,114002202210331], + 1012002030041000: [102014001130210,110002302201420,102421004041011,102240040202421,100130004300103,103000404000100,100040004331010,101203001022300,112142441100101,112420030202242], + 1040002030420224: [114113014000010,114202400003330,111201222220201,114140204123004,114330004003002,114020210040010,112140030420012,100002324211100,114440100001332,111231042242020], + 110340103023303: [110102401201204,100110004103122,103020200141000,102414034040100,100212030414010,100412200002013,114312004002020,102020041321410,102300020220011,111340300010010], + 100021223010410: [102214204030204,112011312002001,101344331000033,100031001030010,101200100300130,100103000420004,112010040224120,101110104203101,102030214011002,114312000000010], + 122300010322102: [110001022000001,100021004310222,110020422131120,100001000100000,110202222043022,110313312021120,100220214333200,110330234422000,110243000001123,114024400030020], + 100240330023040: [100003101032010,100000204100040,102410111400000,102023104012330,101423221102322,114001412302040,100301441003041,112002004004131,102131014030410,100000010002403], + 1000330401010002: [114200212322001,100401210020002,112210322040121,100402042200000,100010111022102,102000224000000,100002104302110,101022440300020,101402010301000,100000220111021], + 1000240301001004: [100102030022032,110004002104412,100300330140221,101010004012023,114020444011203,100041101020304,114223104000224,103414310101301,102300041002342,103311041404230], + 221030002000232: [104111432100240,111102440020002,101000200340220,103312010113222,100034110413403,101230111202201,102123411402002,100014114101200,101042201030422,112410144044044], + 1001130441201023: [110103014401023,100001044310021,114030444102123,110001010030000,110021404214210,102024000201400,100130220400031,103244411400010,100000400100142,102002034001310], + 111033203043100: [111240220002100,110030344201413,101001014001021,100103224301304,114000100020200,102102100231000,114040202330200,100410331002222,100032204311200,102202111110404], + 322122003100301: [110031132004101,100030204311001,102001314010010,100000340004033,102043002003004,102001000222212,102020210213130,100023004312402,100110304032200,111002200022030], + 1013001320000020: [110020001310000,110214024430312,100011014100041,100310201003000,110412121110214,100212341003212,110142300120000,112013212032000,112010220224003,112001040231401], + 1104120301033130: [102021024000010,102300010242330,102000401120420,114011102210402,114300100000041,102222014011300,100100121010022,100002134204321,102114201120000,114401132311113], + 202011103000021: [110100001200320,101243024011000,100000214101311,102200230202120,100010021221221,111012202111021,114410110004100,100200301000032,100102310402243,112410202020240], + 1000220240001243: [110401004221204,111112000011222,100322444314002,101003301020022,100001030100030,112012004004000,112044204000441,103141100104002,110341300400201,100000104210240], + 100432020213041: [120004030002401,114303212321010,122122400100233,124210002004022,102104240200102,111241012204330,114002022300021,114210010004204], + 1422023004220140: [110111400400013,102101300210200,100041044100100,102041014011220,102301104110010,101001000322303,102320001000040,112300031103011,100100140024100,104100042101240], + 220430002102130: [102000010202042,102020001100001,101011014010102,102020324002022,102000144012140,102001104001214,112440104040110,111004410022000,102221241110321,124301340333312], + 220122412202010: [100300031003200,102310031100100,102230121123030,114020402303041,103000000104034,100002021020001,102000110224002,101022121000241,111100004100400,102014000220344], + 111000220211012: [100013100100014,100120234300003,102100014000422,114010422330121,110020402100200,101401424024210,103044001403210,111300122200243,100000101040410,102304010242101], + 214030204134210: [103212000212121,112002010220004,100112110020301,103211014000111,102000034013222,100022301000112,114121030220301,102030021100041,103210214042004,112002042310020], + 1000440040020013: [1010400230221020,103034010121101,102302200210010,111300400002313,111101040014040,100023014313010,114021040010311,114140004123122,102143202000400,100002301021040], + 112022100012210: [100000200202012,114404010003320,100013200412401,100141011011032,111222214101043,100010021034000,103132004002020,100000241000002,100000401002031,103230430101003], + 1140200040312303: [100000001220044,101321001000010,102022200220022,102140114001021,100040400100203,102410111110002,100101041040330,102000100210400,114102302311211,114034400040402], + 1120310221022021: [102012021321102,102141000230042,102002000221000,114044020020230,102321001000211,102242130202110,100010001040020,100002031020102,110200440000121,112400204040200], + 310204001001300: [110000104200413,113141002412032], + 1414420013004000: [101100104000222,102324141000002,101010234004042,102041224010012,114340102322021,103040044010112,102102000312101,100040320003002,100131001222020,100033021031120], + 103324000011102: [114010200011100,100102110412002,100000204214001,102013024000211,101420000300100,111303020011022,110030122001102,114200100002242,114100114000220,101200304010130], + 1400032011022112: [100012230204000,110143101120300,101101200311102,112401402023020,103142104001331,100200204123011,102012024040044,103031120143010,100103401003022,100000010004223], + 102303404030230: [101020204002030,114034220041220,114000204101231,100024004210111,102002100222202,103343010113030,102013000202010,114040202214201,100200001210240,103200234030122], + 1112444322313010: [114423002313120,102302004110032,103100010101002,102300041004010,100241020000000,101403004040100,103000140101310,100000424201102,103111240223100,110040004412402], + 201222004000012: [103233020100000,101000100342211,100120414231002,102011201320040,110400230404040,100001204301011,112010334002223,112234000202010,102222011121001,102000124010244], + 112100002032200: [110111032140220,100023101042010,102410111400002,102112310210202,102330010243440,114042044100403,114221224002403,100013310123100,100022410101442,114200022343003], + 221310201022220: [102100044001000,110041214411012,101000300301420,101000101022043,112400122020014,100222000000120,110120000402004,101000000303020,102101401340100,100002101031040], + 131010044143200: [110201201211024,110202000000310,110000010120043,100422314300200,102141410230020,110020001224021,101110020013040,101012410301010,103120001400003,110003302000101], + 211422120110000: [102102101412200,103003000142012,1002201014202430,100112430012432,103330400114023,102403004020222,100002301031043,100040321042021,1211200224022400,100034231033001], + 1231242044002020: [100410410002011,102101224002210,110311232120010,122203322100011,110330022021224,110123442011041,103021000110211,102201324110204,103010141222231,102102140230141], + 130214040211300: [101042014003022,102210020240030,121401221221000,111134344400330,110020000010044,110111044402003,111043124112002,114300410001304,111012422202203,200000300421000], + 1022010040400121: [104110021244203,102224101113104,102103022002001,100312331004000,102102224000012,102100102001032,100142431013000,101000031001011,101100001102230,101010130321200], + 1100020200404101: [102340221000300,100110020031042,110422102110221,100402002201002,101011014002032,111004100022110,101002201140040,100211000412142,100141021004020,102320234030000], + 1002113311404312: [100440031001120,102203004042010,100020001041410,102032012000101,114014112302234,101004201001232,112102102302000,102141231343401,101231104200000,102112011401424], + 1120000132041101: [111030212113431,103222004032000,102233034000002,110123011200000,101122404022022,112130004021000,100100200021431,112101202012010,114240004000000,101100304021321], + 224000232002220: [100003030003020,100001014100021,100001034310012,102030414003000,101342020314000,110011300143002,102112104004041,102110201023020,100022244300030,101402011104010], + 240020030104010: [102000004002101,101403014020203,100402004300002,100042030120422,112100000200031,110003032000041,100003200120040,102143211343014,103300234023033,100112000410320], + 140104300101112: [112142000203203,102100014132110,101021210300311,112102002011134,103020001420020,110232232034400,100010001031001,100024214100000,101013001000203,100104044100201], + 123001121203243: [102301004113010,112030022000210,102320214110001,114000312331020,110002002104100,102301214110003,102144241343120,101010021000112,101111420334431,102334004031222], + 222022110330001: [110342022000001,110000024201210,114403000001001,112311212021024,100030030422421,101120020304200,102020121321033,100000421021000,100024330000002,114100030222001], + 102400010401030: [102121100212102,110020402120123,100030220004324,103002021410120,100004301032422,103040001223140,114221112332002,110002410023032,100010400400202,113001012400112], + 121020233202002: [100000111021003,1012321211130014,411242003002123], + 202023130044140: [1010400230221020,103034010121101,111300400002313,111101040014040,114021040010311,114140004123122,102143202000400,100002301021040,111020002202333,103221010100230], + 102004430222400: [102402024000034,103012024004312,102214020242110,101140320330114,112120020230024,114234004000210,103221021412001,100000204100304], + 1002043411001003: [101121211101004,101114101012020,110002002000100,103013000104404,101001304001101,102002112041034,102041111020030,110022001201023,102011000200113,100000040001141], + 1010201000232002: [110013202003320,101031241000010,102120231343224,110030332100203,114404232310120,103100034001310,114002202210331,100031301020100,110111032140220,100020010200022], + 112040220341200: [114020000030002,114031000022030,100201211003004,102014002000401,103103241421322,110110200001000,114121012340044,102000400240203,102104304023201,103310300140324], + 1104300002032043: [112224111100141,100040134340044,112004310224204,103030411422014,103043334040203,110422201312402,102120131401230,110302011332024,110200302024000,110210020104031], + 1204001101332012: [102000220220104,114202044111100,102102044001132,100020221030411,100010100201100,103021004000012,102300211004013,114033400030122,102201301110113,100102211010210], + 320034002102344: [101101200311102,112401402023020,103142104001331,100200204123011,102012024040044,103031120143010,100000010004223,100042021022002,100101130101111,112000210230234], + 221423010221012: [103021024013303,121000042140301,1300102201211020,1112301032024000], + 102122001042002: [102113020210120,102201101122100,110202102121414,100102114100420,101012310342300,102321320224101,100002404310212,100020004310022,114012212302132,100430324300003], + 1201112102020024: [114003212210013,110302012103114,103023101400002,110010120440200,110024140022040,100002100100320,110100034200300,100401201010220,103200024021204,102100204000234], + 1413022211003112: [101011004212201,101010304000003,110032022002020,100214230430124,103031234000122,102044021101411,101042001021012,101100104002023,103230011412301,100400000010020], + 1002022000200002: [114203042330220,102102231400111,102100422004010,100032421040120,101004201001232,100002020101023,111100232241200,100011234202334,103343010113030,100031404302400], + 1120321001000103: [102000100222110,102302231004020,103001000141212,102000001133312,102202220200320,100402000020413,100004341021204,100010121034013,100101201041310,114102242313010], + 131001424120202: [112144002012040,102110040210100,100014424203222,100120200402020,111002014122111,112013002310110,110200400010001,110232200421003,102140434004314], + 1422022000120400: [100012320012022,102240221121201,100003021042014], + 101014034044122: [110320202023400,110441234224400,111431110000042,100302141003012,102004441124110,100000301221024,101224322120022,110104422010121,110013122130200,110200010014000], + 101102013010121: [103032221421243,100120004300002,103210030110012,100112224000220,110302010102310], + 241002001412303: [101400331014100,100002011233223], + 111021400102120: [111210000001101,114013400011030,101201104040034,101020111030400,103004104010210,100202200003011,103210210100210,101013101033100,102204204042220,110100301000100], + 140324210404000: [100112021020320,114212104110100,102300124023122,100000104100102,111022134112141,102001040222000,102101004000001,100121214300000,102001201442022,111103214104101], + 243420110001000: [101100010302233,102300341002000,100100201020222,102142210212103,102310201001230,100102111040112,101300004220004,100340121001230,100131401010130,114210012331102], + 123001440030004: [104120011242011,114300000000002,110121100004131,110020002104100,102111400202120,102000301101102,111400214442024,114100124002210,111122200021102,114032234033303], + 1121133012002124: [112413224040101,100220100110400,101200031020230,102403004042342,101024001034211,111122004101222,114001012300002,102121100232012,114000222213021,114102330210021], + 1000101011412220: [114014112300100,114030034013101,100000044204004,101013004001421,103000014011004,101020224210014,114202244101041,100122310020400,112423102010012,102112022001414], + 1042021430010022: [114002104014300,102000311102212,114032104100141,112301312020123,102000201101332,100111304300020,100040404202000,102104011413013,100012011022000,112100000200003], + 1241021303100120: [101040040300223,114234004000210,100100001040410,103000200112220], + 112300400022304: [103122114004113,110030110122402,114322024034312,110000302123230,101344140314114,100100244231020,102100201400122,102110001141443,100323024010040,100234004033234], + 1001402002030104: [103220120212134,111103314101000,114140104122430,101100010302233,100100201020222,102020201413321,102112100224122,101002020303222,100131401010130,114210012331102], + 1122000010012011: [110030122102303,102300001002440,112402034013000,101011020320030,112202040411432,112130004043234,110013020024300,112101120201010,102010211120200,100400202201400], + 1110333204411202: [114031004022301,103004324010014,100123221201001,114000042300000,102221144011031,102004131102034,102034000222030,103310000112400,114200200004000,101210014042024], + 200412034401342: [114301022320021,103344200113430,114101104102004,102440024022132,112100102012303,303020404011031,110432112113300,100141014232130,110020202100303,100400032200000], + 1403011410021221: [101300124221002,103311100112220,102112002004120,114400004141104,102142234000020,114402044140023,100314420140013,101401204040200,102132004004123,100040021031201], + 122103302004140: [100111334330000,110023240021020,100300433210004,102240100011000,100400213242110,100020201002004,120021202100230,102320120240200,100000012221111,110102301010411], + 1001042021343004: [100012134302230,102012110232021,103300201400340,102002230200001,100020000100311,101444031100130,114404214140114,114400032310444,100120031042012,100000101002424], + 103114102420124: [102300001002440,112130004043234,112101120201010,101000224223002,102101101021304,102012011412102,101040201112304,100024204204210,112422342020141,102202000232032], + 100303300001220: [103212014020132,101022000302211,101232020300432,103011200100000,114020204024101,101031320320042,102122340200200,114000214021240,111111000020023,112012112300040], + 300211040102220: [100030324200410,101000001111200,102300404024300,102113200210140,100040041020102,114200020003431,114420142322140,101002200343110,100212024322044,100140004102001], + 1022114310032034: [100010001043004,100020101230201,111002200021141,100410144320420,111200044424130,102331214112200,102202031302001,103301000140031,111100222112000,112003102000220], + 113010000000223: [100200400430003,114420102323300,110112030401012,110212022133311,110404122110112,110403010000304,114100040214000,101210021021243,101010200320244,102214000210013], + 1010042240201220: [102400100230000,101022121001000,102302020212101,102300104110002,100030004104210,110232110004010,103021201430000,101002320322420,102220021110200,103003004000110], + 222300242010031: [101122414004224,102000201131020,1010120030012200,101024411001024,102123332000002,100000020401203,100202211200032,100020140120213,114020012211102,101221400302004], + 100430420023010: [101221020040220,100103104302044,102020004000014,114242410001010,102000220220104,114202044111100,114212100211223,102102044001132,100020221030411,114443114123130], + 122200101300000: [114030400020232,114010204022042,110101202010123,110000011220401,101240300302320,103001024000200,102421020202030,110011014203122,110001031300042,114100214000010], + 222111040000042: [110000100022040,100302420120212,114004142244000,102140001441301,102002004012310,110000011220204,111200024102040,100302304310204,102103204000000,101330120302103], + 224100000424024: [111000100012002,111102010012102,111300030012334,110012000141104,140300020110000,112000021130124,100020200102220,114300232301422,100002124340103,102412140201410], + 1030010211000220: [100440024301100,102022200220022,100101041040330,112122334022424,103341124011404,114010214101003,100031130410243,112400222021010,100102101041221,102231101122002], + 123110303100011: [100024401024001,101141011141300,103101001213344,112020102004301,110310211331000,111031000041022,101324314210203], + 1001112241101222: [102420424042020,100010001032223,102111024000402,114321002320001,103220011411101,102001011100100,114402104142102,102311120222404,114020404020132,101220111023331], + 1433200344420042: [103134014000340,104103100010141,111101222240010,100040210411102,112014022314210,100000014100024,102010000221204,100110004102034,102040140220220,114010400014304], + 202001012300230: [110102042010220,101020124000413,111210000001101,114013400011030,102202000201220,101020111030400,103004104010210,101220024041000,102010300201414,100202200003011], + 231110034011021: [102114000202302,111042000041011,101030201111010,100023124103021,102120411023000,102000000240101,102201110212212,102020214011010,102201301121001,100000121020141], + 110200143340300: [100302224314022,102202121303004,4000102402020203,212212122411010,403140033110010,1042001130040011,400220020302030,401000212302000,1104240221103101,321220000111343], + 101421210111002: [111000242201231,114030220011120,110020442001124,102040101121143,100010021211303,100002210000020,102100401140202,114100000031040,114311040000110,100000014312111], + 1240010013233101: [100230000102310,100040004210202,102100200202110,100220222000100,110401304243400,101430221010100,102130000201200,103304404012414,120440011014232,122042111030110], + 102020443022000: [110004020020022,103122114004113,110030110122402,114322024034312,100100244231020,102143432000102,102040010200101,102200434012013,112000301122111,114001110033210], + 132242000010121: [102101201403410,114001002200014,112210400412120,114130200001000,114234304112011,110240221202310,103100241442411,114000040022014,102142021343003,102022104010020], + 221021130001210: [132344004001203,114303202300104,100210304340400,112020044000400,111201314412204,102000200204141,102100300233312,103041130110112,110023014202232,102220021304234], + 132244142112342: [103043404000202,102100422004010,100032421040120,102420000202033,101012400343401,100002411021201,102110010210330,100012020410400,102122111402420,100031404302400], + 114222214100402: [103100121423010,110031024200343,100110411011010,114010144020122,102003121410401,100020104104422,114112012310000,114002340024001,102220111122102,102030200223000], + 104002232134021: [102040431121110,100400002201113,114111100021420,112024212301420,102212000200124,100300310140241,100240134323001,102111024000402,114321002320001,102042000222002], + 120310032110140: [102412004000132,101233341022410,103013314020203,110120211001001,100300400142001,114100210002202,100000120121031,110010102030411,114211324100004,101212311020000], + 100301101400040: [100020121020300,110412121110214,110142300120000,112010220224003,111110010022310,100200001001300,100012104313201,100002201032401,111301332200104,103012011412220], + 1024021010120212: [100000200202012,103220011420242,100031201030331,100141011011032,100010021034000,103132004002020,100000241000002,103201101402422,101040004210301,114400100002010], + 1020000142002200: [100020114101410,112102014020004,102104020200100,112012302000210,401110200120200,100100200104200,110234020001000,100110140003001,102100030200212,141100032211221], + 1000032141200121: [101000024004442,111423000022420,140102120200000,110131001002021,100002100000100,203201100012000,114100102340003,110130030020000], + 100304110420202: [110004110141201,112020022000410,100010004203011,112210210200000,114112022340200,112033012312000,111230202223302,111230010000204,110201002224022,110010012130243], + 114201103003000: [100400002201113,102420424042020,100010001032223,102111024000402,114321002320001,102001011100100,114402104142102,102311120222404,100100000422320,102100012002000], + 1022241430000010: [102310000222133,100112000402300,114104310000002,100101220021240,102220011122100,100001001034141,102040244041000,112013032002214,101404441100012,112123102010143], + 120002012424002: [100012320001320,102000331120104,100232214222204,100040324331403,112104212010101,100001104201201,102300221002020,100002101020010,112010202000202,102033024010010], + 1020220041032400: [102100004130301,102113020210120,102201101122100,100102114100420,101012310342300,102321320224101,100002404310212,114012212302132,100430324300003,114230222331120], + 1001041220131003: [100102011010403,100220000144000,101044334010021,100041230103400,102343201103202,110114140030310,111210022244041,112001112310011,100014020100410,122102040020030], + 233144340323320: [110130321300301,102311104020002,111020104110202,100311014020202,102240200242002,101000411030013,102110312004000,1003110100202043,103012004020122,100313041004240], + 1004201001302002: [114402020004242,112032012004300,101122414004224,1010120030012200,101024411001024,111102044104010,112220044014012,110002044410023,100010410420002,102120011340102], + 112402320401011: [101400100302311,102141000230040,114013204020122,110030024202101,110100224200101,101122201021010,114000102300220,111011022203010,103021424001214,101230000301220], + 1040411020320000: [100004001021111,101021004214202,100003000104203,102114320203000,101011001103200,114001112300001,101003104212220,102311110240101,114002002300302,100000304301120], + 103001402220032: [112100124023402,102000224000011,101020044011003,103122000211420,100032301041204,100410304320220,100002414210010,100012024200214,102402000204104,102201431120044], + 1412200200200012: [114014112300100,114030034013101,100002100412200,101013004001421,103000014011004,103200000101100,114202244101041,100122310020400,112423102010012,102112022001414], + 1012301002111444: [103340041403223,112002110220340,100000221020014,102003224000022,100010031222001,103001114001210,110043222124300,100100420400004,102023001320134,110004002130020], + 1201144002420322: [101011004212201,110032022002020,103031234000122,100400110020244,101042001021012,101100104002023,103230011412301,100400000010020,100124021201021,100411201002420], + 130240304000021: [100022211042104,102020014002022,100100204230423,100423202201102,103131000120022,110004021102300,100130001021040,103000034040110,103100214000400,114200122301402], + 1024133010302002: [110130302012020,100000211021004,102411134020204,114032200030021,102000000224012,110210120000001,101000120303020,102000001133312,100402000020413,100011044210004], + 1010420010110213: [100402040012140,100404400022030,101001231111022,100404002201203,100402420022012,100021420004400,100030424340022,114140304003102,100110300003140,110012220020220], + 100200210113401: [101214200300004,114330120000222,100200241001404,110001440004103,110010022202202,100003030202011,1000301003020410,1014111023013000,110320044420300,1003300020121100], + 1001400300112324: [102000000210211,111010204401023,103142444002002,101200010300001,102211300204221,112002132303300,114420232314210,100301004321221,101104100331011,100020000410313], + 103033401014214: [110311200403410,110200201311102,110000200420204,102022120211140,100101220411134,110011120132000,100302010140002,101012340321223,101002034212140,103001000113103], + 102400223110011: [101121211101004,101114101012020,101001304001101,103000110142041,102002112041034,102041111020030,110022001201023,100000040001141,103101124003110,112401144042000], + 1433100202213020: [110032022002020,112032040234431,101004310324302,100120040400011,100124021201021,101240404044020,100200111001432,112213021100032,100300141002203,103141100112400], + 1000311110100014: [114040204014042,111230032242001,101221031020331,103230004030322,102102001341000,102300200221021,114024104032203,101220004012040,102112201341440,103012204010041], + 1024432400212222: [112224111100141,103030411422014,103043334040203,110422201312402,102120131401230,110302011332024,110200302024000,110021340020022,110210020104031,113130020101411], + 141102310010040: [102422114040010,100022041001002,111240340004003,111101222244030,114032424122040,112011012004300,101021401003220,102020004001311,100101101010100,100301020420101], + 1001022400033031: [112004001122300,101301124222004,100124124103003,102130004020041,102002000242023,100000204104002,110200421101001,102120040212043,101101324001310,110011002133011], + 241142020002041: [101020201000000,112404124041101], + 120204001003300: [102343230224321,114201104111034,102310140240012,100014204201000,111130210020000,100311134323020,101232240300002,100141101044100,102132210202100,102132401400002], + 1120030202401014: [112113214020100,103300344012201,100122200012014,100000130013400,100011200201400,100001321032243,100201104224131,100002100204114,102211430202033,101031321022412], + 100202310004010: [100110210024121,100141230401100,112220010202202,100030044340120,101210021011110,100302124213224,100020100200010,100000024100431,100400000033202,102012004000242], + 102312022030011: [110000204210130,100100100422103,110020134410001,100021140000322,110010011212411,100300020142022,102101002004300,102043001021033,103230010114302,101210211022100], + 1111121000043000: [102033021130021,114410012310230,114000332303001,100022224312021,114044240023401,102101122004040,100111100013032,102121204101001,114422104140213,103042031400033], + 110410003240300: [104111021244202,102100001444023,103220301400000,102124231401212,114202024111304,100210000430203,112002200201220,111211240004002,111200232204041,103201211404114], + 100003112002143: [102240120244002,101003204000004,102204424033103,112010412020141,1002001101203410,104223421402434,110020102120001,123300114110104,120410102000030,1111320100340242], + 100010010400100: [111320012221132,102302144110440,100002320411400,100143034304100,114021002331014,100041004200042,100032024202240,102144002001240,102020224000000,101242101020042], + 132300002101003: [100001300102001,100220101204311,112033124022002,103040044010112,101013114001130,110022134210202,110110102042312,110440211340302,100001300000022,101004104010020], + 1102000110131201: [101020000300112,102203344011410,100021324100000,100002020410020,102012220241003,111120214102000,103130020213032,101430211012120,100204021000012,103302140112020], + 102120412004000: [101300340341000,100111341011011,102401001400103,114421030000000,100130200020214,102044001440122,102300021100000,102400304042142,102223314042002,101200040300300], + 100010222022030: [101201111021101,103131044031101,101001401034300,120001020012001,102121042000004,114304304030022,100000220112324,111212420010002,114132020000020,103304000111011], + 132032404422002: [101220040300414,102121211343322,1320004203402400,101003140301001,102410001111322,400020203022020,113210210400400,110102000002203,400100441040022,1302200002412211], + 110000222100430: [114410024110002,111200210001023,114402014112002,102032022000041,100020000120134,110202001212002,102342022000024,114000222330121,101401204042023,100113021020101], + 202010003104131: [103044010120003,100142011022211,101000401032212,103133031440020,100110021040020,102300121000004,114000242303001,102021111411014,103003101400121,114210002324000], + 214023340241121: [101221020040220,100103104302044,102020004000014,100000211023014,100201111002224,114242410001010,102122140202012,114202044111100,102013420220240,114212100211223], + 230021400233213: [111202004134000,111320012222200,102110314002123,100111121000000,111131124100300,102113100203200,101002100324041,102021200243200,101000004040002,120000010010420], + 311002200232224: [114012012330203,102100020211003,100000214102101,102230121123030,103020031420410,103100124003243,102033200222311,102000110224002,100100104102000,111204302220322], + 1010400043111032: [101100004002101,102121130221024,100031404344111,102001210223212,103113014002100,101002210342202,102034001100100,101400004040120,102141004000202,103030034003020], + 1134100000000200: [110041030000202,114412002310123,102000104000041,102100034132002,102101120211200,121000000000100,114021014023400,111200440012012,102101020314221,142220010022203], + 110000042232302: [101423400300400,100003101003001,114301120000030,112004000214201,102221002020200,103113211441220,102300104020420,100010320201332,110004224210020,100340111000001], + 1001001011140010: [102141242001000,100121124234400,113000110124020,100200210002032,102200002021302,104144130014121,101221024231200,110303042210442,110114012012120,114224420001001], + 1413040022003011: [102101324130010,100102004100201,101400300300111,100100204101010,102114020210202,101200200302210,102434211400021,100003000412141,102000032043210,101430001014014], + 1041122000024121: [110023342101220,101001421031220,100021004310222,112220322030220,110313312021120,100220214333200,110330234422000,111000034110311,102200001002100,100014100124121], + 213123410131410: [103024420121003], + 104120201030001: [114300304001000,103204000110000,114203202330210,110214110004122,102300121000111,112021020220112,102000401102000,114212000211101,110021204411214,100024144201210], + 322001302013220: [103030411422014,102412044040011,110021002124000,112200030203124,111200302220111,102004020224404,114201024101004,103243204020001,103412020130043,100400042201003], + 130020004000100: [114000044020204,103044010120003,102320000221020,110142020400012,100142011022211,114230344103210,100030020104423,100102011010000,100000001021041,102000000212122], + 102000032000030: [421010020300101,110020102030110,400220020302030,1320123230012100,421400202010301,141021012220010,401012402004031,1400122214300002,1200002114313302,1002220011001240], + 1100012002230021: [110021220021121,100002120412400,103322424033024,100010130140100,100001214302342,102233204000002,110301020401421,112011011132021,112022004000001,101030240322011], + 1003010200022021: [111223402220443,110430000400002,111121102240240,111320022200100,100300001002041,103032201404142,102203001120342,100100104302010,100201210430001,114022042300011], + 113411421301032: [110040022130003,100030430422242,101120014204000,110014300001402,100100014230110,111002132202012,110201004241002,101000131142230,100104044230000,114022024012213], + 130411041440042: [112224111100141,103030411422014,103043334040203,110422201312402,102120131401230,110302011332024,110200302024000,110021340020022,101010001000320,110210020104031], + 1042000032143111: [110104112010103,111102004100101,102202414041044,102000104012232,102021100220101,114443330001442,100230120001003,114000040010421,112042110220004,112203221102231], + 1120140104114101: [112144002012040,102110040210100,100014424203222,100120200402020,110232200421003,102140434004314], + 1001200001101011: [114020000030002,114031000022030,100201211003004,102014002000401,103103241421322,114121012340044,102000400240203,102104304023201,103310300140324,100002224244002], + 1040043023022220: [112042210240113,112003022001322,100402322200000,102211400212122,101420111013041,111001024412012,112020022312414,100114110003220,102203040234024,103100334001032], + 1044040413200020: [100401140034220,102140041342420,101013111000000,102102131340404,103011100120201,102002030240400,101322200340000,101301420312101,102013320200210,102000040221010], + 101242221304324: [102040431121110,101221020040220,114111100021420,102212000200124,100300310140241,100103104302044,101041030320401,102141212000200,102042000222002,101203121020430], + 1001041111000202: [102100001411312,114041010012000,112000132402200,103134244000000,114022210020000,114101022332103,110200014242110,110232044241140,103040124004000,102111340102001], + 1002413022021002: [114020000030002,100201211003004,102014002000401,103103241421322,114121012340044,102000400240203,102104304023201,103310300140324,100002224244002,114310200002400], + 1000022210010013: [102101324130010,102140000212141,102424114020143,102023021321020,102114020210202,101200200302210,100001300100302,112220234010010,114011012302220,100043031021303], + 134212201022013: [101302101002110,103221220100201,102102000002043,100244401122022,110323040404100,111110234102140,102330104110020,101012220320104,102041211411101,102110000212004], + 100340100212031: [1020110422203030], + 1023004204100010: [102000214004032,114031004022301,103004324010014,114430000004001,114000042300000,102011004002201,102221144011031,112011120220402,100000104200032,111021200021002], + 100401000101034: [112004202302034,102122214131011,102100104000040,100023031000024,100010044300003,112120224040040,103301410110110,100020004101012,102311011000200,101032001032200], + 1400223342434010: [100032304102001,120300311344011,100013000001010,103441300124002,111233112220033,114201012323230,111100014402104,102100321104001,121000311034110,110303202000004], + 1100101010110200: [101201104041401,101402011014002,114410012310230,101423011010400,102141100210112,100001410002012,102230220200002,114130200001000,100022224312021,101011104014011], + 200002321334242: [114220040000201,111040032200021,103030040121410,110240134211002,110022102131032,102241044033231,110000312201003,110011022130320,103004004001222,103200314020032], + 323310014122421: [102011301443332,101000024000234,112001002031220,101022200322200,100000101020001,110010314200012,110110202002010,100000314240000,110122021340041,102000022043221], + 1013223040413212: [110400022010030,102130411411444,103100214000130,103103204000110,114040410020022,110000400030340,114142102344221,102404004001203,114200100000143,100004120102024], + 1001012402400400: [114000200020423,103133114000010,101002000301002,112000302000004,100024210411201,100021004104234,100122010031003,110040401220110,102120020200301,102121301343040], + 1020203430213120: [100002100124101,112003100241220,102204304000304,114003320044100,103040004011113,103030130100011,101110021040110,101040040300223,101124014000140,102144401410210], + 1000413314131102: [114032234033303,114300124030100,112011204004112,100003000002034,110102022000200,100202031002101,111000004401312,100141401002001,100121114230123,100003120410040], + 244003141120022: [111001440020003,110200020010003,100002214100100,102120104003011,102120402000014,102000200210032,100041000100422,114020002303212,102103132002023,100022200410202], + 1104100004210142: [100100331000022,114222040214020,110200004210000,102032000223300,101000441140230,100142221012003,111300214121201,100100030402001,102202021303043,110132124400400], + 100020010002004: [100022102100243,241221402002000,1030200104020421,1000102021230333,110344021203140,4002244101001011,100022020402123,101212413013223,100004424041022], + 1121121410102101: [102121201340001,102200211120103,110400242110410,111302204123234,114132040223044,100030020423044,103013104002044,114211004004210,100404202200223,100034204310001], + 1032130214302214: [102001444000222,100200004301323,110010030440201,110020004414024,101400134043222,100010400013202,114340312301134,100031220121003,114310242320310,102110021401100], + 1011213412110330: [114011002300120,101221004042212,100303111000101,101410014021040,102011101321222,100010001023120,102002101120132,102242210200010,101100320320310,101000004211110], + 1012000202400223: [102002040220110,102141220210212,111202024134001,100000014100202,101012104001020,103101031440430,111422202210212,110213142242220,114104332310202,101210120302002], + 213023043010001: [114001330013202,111031034114101,103301034021201,114011114102030,103043311403202,100321210142302,100002001032110,101022401140100,100034220000013,100111211020234], + 1044140023201100: [110443000000102,102430100200123,100040214102300,100002214202010,101424010303040,100034400410112,100432301011001,111020012203011,100100111043114,100000044241022], + 1032002101243121: [102140024002342,102312120222342,110002004200112,102020010221120,112012000232203,100000241020200,102143121343400,100220001000401,102101004002030,102303130242002], + 130020031300041: [102310000222133,114111000222110,112034040231012,114104310000002,102120001144202,102130201140012,100010204202202,112422320200210,112100211100021,110040030004102], + 130231001400230: [101221204230013,110402412220402,114111000030014,110340342021001,110124022140001,103221401202301,101200120303240,101000311142402,110001311304140,111230402210020], + 1222201432204100: [104421312102244,114131014101010,102240214041033,103010021422042,101110000010122,102100404000021,110323002022000,104123302100200,100034004212222,100103414300020], + 1040142121420240: [101032111230411,103010110120020,110100032122000,110304002000013], + 101322000230140: [102102430310202,102002301410122,101010000323030,101001414212120,102142020212310,103304004023413,100022201043312,111300032204432,114142200030000,100030001042331], + 100200200031002: [111120014101000], + 1101202141103042: [100000101040120,102323320240010,100122124300402,101022344002202,100031041030040,102112101020021,114322304002230,100010004200110,114313044003041,100030141000000], + 100140444122022: [111200200000232,100101001011114,101430004040203,102210314111120,102220024122101,112022140234004,100143440001301,114102104121201,101121000303320,114110034120012], + 122002420020423: [100002100100320,102043221012112,102024401440202,103200210100110,102440031411200,100023014340130,100113210103120,100041430100100,100432200030121,114121144001400], + 1032041310004020: [101440004041120,101031214000041,114112020212203,114302020003041,102110014030002,110201200000101,110110000032030,102001200204101,102033340222200,110042402132412], + 121000000401010: [100440000030040,100023101001004,102101000233302,112130010202041,103210210100210,102012404000211,101043004211000,112340340200112,100001000010010,102141010230441], + 1020402012012134: [100121230031032,112000431120410,100122200012014,103042024040104,102304104110001,100104211044110,114241222321321,114021002302020,102313204114304,100013200100011], + 1004002410242200: [103004204044030,114111042314242,100002210100000,100101001010214,102334004110210,101004004000022,102331410242212,102200301122023,101021111004000,110204042020220], + 130230141020221: [100000400000241,111102214104403,100140024230240,110021340020022,101010001000320,113130020101411,101022021030201,101000031010000,110000400440240,100130334030100], + 1420210410211000: [100304201000221,100112021020320,103010001422020,102300124023122,114221004100020,102304100210334,100403210010142,112003100241220,102204304000304,100301104104210], + 1430020331140440: [102001200221011,103101024004200,101000004010012,103024000103302,101301014220002,102202004011044,101012044004042,102020304000321,100104000101010,114040100011424], + 143302343223100: [110102042010220,101020124000413,111210000001101,114013400011030,103004104010210,101220024041000,102010300201414,100202200003011,114330432320002,101413004041201], + 101100411240000: [100111014100342,102112300201410,112123142010120,101002321032002,101121100013002,110240202042221,102010101411103,100010400002103,110201004240242,114200002321300], + 114124122231102: [110102401201204,102400100230000,102414034040100,100212030414010,101200020303202,102020041321410,111340300010010,114120420223002,102013224003020,100002210201212], + 1013203121010014: [103200001403001,100003044300001,111110400340141,103200001423140,100033334104402,124302202010112,110002004200210,100011004104011,111112212214110,101003000323004], + 242110000000223: [100020220410142,110000412003001,102011331131302,114000230023300,102021204013000,112042024000020,110022100044100,114400200004310,110003000024101,102400401412102], + 100030110410012: [110140332002220,100431240001030,114020204021302,114002120022004,100011004341114,101230000302010,111002202200024,112241010203003,110300032004002,103000204042111], + 212140002022024: [110403302023130,110001004204310,100010311020030,114001004100003,100020000200000,100141230020203,101031121003021,100200120030203,103111201443022,110101214400030], + 101210300314301: [104101321240004,100020204211040,103440104004241,110213010400012,112313000202012,103010144014002,101112020330001,100012020121041,100402002201240,100000234202000], + 103431420040131: [100000311221002,101120321040104,110002300420010,110021002003020,101002004004012,101024000320213,110210221302403,111202020000412,103103121242024,110202401311401], + 1040210321213131: [110000402130200,110210002110430,103024004010134,110102204202001,100141101040123,110422420030000,110004102001020,110040002032114,100120414100102,102404224041131], + 110204341204200: [114201010001201,100030024300201,101041404002420,102220310200014,103231224012042,100040300102020,102400110230001,102101011342100,110012404201130,102311210240013], + 1134012004302203: [103102101422031,101421100301230,100003414100400,102022020204430,103214021400010,110100022010014,111110420014032,102300131102000,103144220102102,102300010220421], + 1104221204000312: [112042002302024,102230010201400,110100232210231], + 1001010120014112: [111410210001002,101023020301100,110200332041001,114000332302320,102100221341001,100040004304002,100011301000021,100100001040210,102014001441210,100013224103322], + 1121202242010140: [102424204043100,100300211000020,114310200002400,103211220100010,101202201021310,103044004010022,114130020222342,112301032022414,102103100310300,102012014002001], + 212223001031023: [421010020300101,110020102030110,400220020302030,401012402004031,1400122214300002,1200002114313302,1110002442211200], + 1122020000323210: [100303101202010,100201244032040,112012000212410,110022134202000,112000102000300,102000034013010,111002200040000,112010102001040,103012100122324,100022234100402], + 1011311222000000: [100131031020002,102323304112342,114003222201103,110240020100212,100022204300000,112012211120102,100101040400110,110414011212320,101002204001310,102203111103200], + 102000144030020: [100144100410414,102022001101400,110232400010300,100312030012210,101120204202002,101043021124401,100003010000000,100000404100023,110014301320111,112413022010030], + 100002300002001: [100102204300424,102011041100210,101013234000010,102002010224011,100102440024402,111003210004030,100200020320224,114300104034104,102002221442200,102040024010022], + 1141342313200112: [101440004041120,101031214000041,114112020212203,114302020003041,102110014030002,110201200000101,110110000032030,102001200204101,102033340222200,110042402132412], + 1441002040042221: [122020000401001,103213202221202,1200300001400200,1422242000120411,1310011200200021], + 1002104301212122: [102302024112212,103000020120303,100123000422310,100000040410034,100010030122310,100003314100400,101443104041443,111210102220243,114002410041201,114014212300202], + 1000100240130011: [104404322124241,102032031130301,114030234020304,102200124012000,114002120023020,114421000001111,121400013334402,114413200000230,100103201040210,144000213202010], + 100012240040012: [100222011211021,114034030020130,114031112210241,102120341340120,102422310203100,104134440011201,102311021104000,102104220213400,112021011112000,114224200210241], + 101240000130121: [110000100422111,114010314101200,102341014010003,101000030321400,114132202312102,114322134002204,100002320104400,101013024002120,100021110200330,110322110010000], + 100000000232412: [100023421041402,103101224000011,101010224000130,101144134001102,102200042000104,103002144042123,110012220002021,102304204110040,100210020410010,101000414002041], + 1011140130320011: [100223214121011,112024121130304,110004022000404,103020210101200,110010012102144,100413124100101,111002132202012,112000111120040,100402300022230,111004012200303], + 1040331020100220: [114202002324000,101400344004430,111002032144410,110043440012000,103422400130011,100022101014301,110140422120001,110030101320220], + 110004011011110: [102120101340040,100024114300020,102424311110001,114003234102244,102112434004041,112430202020210,101412044042002,100030101230302], + 1103103010402032: [101003204000004,102204424033103,104223421402434,110020102120001,123300114110104,120410102000030,414300003320310,1300113414104011,1300000000422020,1022122002201141], + 201321003020230: [100030231000344,112311011101001,110100124402042,102120404134413,101100200330040,110040212000010,114102124000200,110211202030440,114440012312003,100000001024104], + 302101132112303: [110202400003213,110001012101334,112020114004303,100001114302424,101222134011002,112113012300242,110343232021004,114131044002441,110040142002100,102202040232030], + 1020301141112011: [114020000030002,100201211003004,102014002000401,103103241421322,114121012340044,102000400240203,102104304023201,103310300140324,100002224244002,114310200002400], + 102114011311020: [100020121020300,103432001210300,112440134041000,100210240013000,110401214242400,101044214042221,100033201031241,110010114210202,102141000313022,112401010202200], + 200421432024201: [102234010200304,100314010143240,100012431020012,103042024012204,112210204003320,102200100204220,111200104100341,101124000303020,114402000000000,102201111111000], + 204022420041320: [112012000220043,102414000203000,111101400022211,100024111043000,103301101400021,111320100000001,111101002213022,101032440340020,112002202000010,100002011021004], + 1100104244331020: [144131233204044,114213002340022,120130001004000,110102030010210,102220211120002,114014010033321,101400104042212,1003022312322100,102001244001224,103441112000230], + 120104110100000: [100410410002011,102101224002210,110311232120010,122203322100011,110330022021224,103021000110211,102201324110204,102102140230141,114024030010010,111300224101004], + 1031414000430410: [110143110121200,102111421401032,120002030230003,102012021101203,102000334000402,101020324214241,103033000141023,111122310010100,100203424332142,114010300012240], + 1000101010404210: [102222111120010,103200224033413,101210001201243,102300440221022,104120201242031,102320110240231,100100101011200,100133001220421,100122204301312,101022220322100], + 140432120102012: [111130104100013,102220014033403,112012224000211,100420301002201,103401300130041,101000204011334,101401001100232,114102214101001,100020021040000,101040121034010], + 100342201002000: [102010114022011,103340041403223,114002200000421,101020321002002,114302210010001,114030004104220,102443211401140,100000221020014,102003224000022,102301041000014], + 110432321140112: [101000411020133,101414020330014,100201231000134,101010024000011,100331424210202,112010102030100,100232101202101,102204420200200,112100321104011,100011024312240], + 1001022420021440: [110220100000102,102100321320100,102102011414242,100041004100221,100000000412112,110000010033022,102330040242220,102310400240000,101201340300430,111320312222220], + 1001030200040412: [102101304002000,101030221000424,112000212303013,110000201302121,100403010031203,101110401101431,112134044004324,112130024001100,110402020104000,102122000310041], + 211211212034020: [103000004002012,100002011042020,100301421002002,100202140000111,103200020111014,100240101000030,101003104212220,102302211002004,114030310012122,100043021042120], + 221032403313010: [103100314001030,114101004121020,100040301042132,114010040023411,102001010222103,101021104212100,102102241341004,100000101030412,103031000121000,102020300220201], + 1420301312012202: [110320202023400,111431110000042,110301030010140,100302141003012,102004441124110,103303201400021,114101420030202,114421242204443,100000301221024,101224322120022], + 1004400413122011: [102100330211131,100100110411000,101022024040420,100102041041010,102042041133200,100004001232022,114134310001022,103043401410010,103401144020023,100103010001340], + 130230100301310: [112000222310334,102010104000124,100004001003032,102102100210000,100211024341103,100100104303313,112000001132100,101024211030001,110400002110220,114013402302413], + 1000200302200200: [100002200101330,100000124302040,114000000014113,101210011042021,101122011100024,100400020020010,112420044040112,100422102201100,110200120003024,100002341030400], + 102010001144040: [114200024110022,103012100110444,103002201240003,100211104104241,100103001220002,101000404012321,102230022023230,100014200003002,110320022024110], + 110200114010040: [111323002200100,100021044202120,100442004304040,103102420121202,102020120201002,110001000034023,111041104111423,102130000233203,100014030122210,110220001312011], + 1020330401141302: [111400124420002,110201400400024,102401000201121,111013232200403,102112220202010,102214104010210,112010120231202,101011101032340,101013411000000,102100001400004], + 210041041102222: [100301031002201,100000224311320,102120121212031,112000400223100,102022031324020,100211111003420,100344041000232,103123314002423,114310332300121,112322031101041], + 1240030220122111: [110222020012300,111012104400010,114244120001041,102120111142201,110010011212411,100300020142022,110102322040111,103230010114302,110010220000210,114010304010030], + 1020021240140000: [111000100012002,110022140120012,111102010012102,110024140142000,100143040411011,110221322123012,110214044210422,112000021130124,114021002302002,102212104013112], + 1102002041342001: [102342014111202,114102020422002,202013001110004,101200020302200,1320010210001300,200002003223300,104211122232004,112303040200001,100224410030410,1101040131142040], + 1001044222104201: [102340221000300,101000130320340,112401314040311,100110020031042,102011004013000,110422102110221,111200122222334,100220124221000,100402002201002,111110004402021], + 1100004201021303: [112413224040101,100220100110400,101200031020230,102403004042342,101024001034211,111122004101222,114020040013100,114001012300002,102121100232012,114000222213021], + 1402100032022000: [102012220241003,100402120030401,114211202324143,101200314040213,103302140112020,114000012303410,100000004300102,102120401022130,101001020331204,100401414322303], + 122120100003231: [100023031021040,1000200300200300,1000012400200022,1031400000012040,110042001100100,400102021402220], + 1013204030122134: [100122004300410,102000104012232,112400202020003,102000224000011,101212040303123,100021021000101,104240010040022,102030200240232,100011124202310,100030300124130], + 233320004200012: [100024000110221,114130014001202,110010220103020,111004100022110,111001344400222,101021204010011,100404410022320,103012101410102,111000000000411,102131304003000], + 1022233030300201: [102101211411000,114110200212210,100102224033421,100104101200201,102021001411110,110041102012100,114222010213042,100120430411222,110014314410140,100022014302423], + 121020001104001: [111104102242110,100002200410230,100044010200300,100003010413400,103334120114003,114032124013234,110112131124012,100440221001232,102330104110220,100020311020134], + 1110110103400402: [102030000223410,111101312240400,100231124320130,114000010012243,100301314313133,101332011001000,103310401401023,101300130344001,114031020030012,102122024020030], + 101430421314210: [100122200020013,100404404302042,114010010024103,100004004210020,110202220010410,102331104112002,104100010014103,114132002200241,102330144110211,100404000020300], + 1021403341210330: [110401004221204,111112000011222,100322444314002,101003301020022,100102431021300,100001030100030,112012004004000,112044204000441,103141100104002,104110100014103], + 1131222040201202: [110020000440124,101340424220112,100122211044424,103432211210302,100400100022034,112201401104040,100020230104020,114110412311002,113400100100120,100212324104022], + 110004012140200: [102023210204300,100130101023140,100141314304233,110000004422320,100021304210300,100044304100100,101012341111024,103132204000234,100020001044140,102403104002033], + 1010013220020020: [112110020230222,114212004004022,110110001000304,100310110420131,110001200432201,103012010110411,101034110320031,110140024221300,110041312130304,114300012300100], + 111220100302000: [103443024000000,114030204021200,100141321000100,102000104014100,114002040020012,103200130134002,100102104230003,100014110200201,102304111004232,100021220000042], + 1003320021100100: [111040032200021,114123234100223,103030040121410,110240134211002,110104000024100,110022102131032,102241044033231,101003221141020,103112000120002,110000312201003], + 1104000220000012: [110231040000334,101024014004200,110432120402013,110213022123233,101231220303431,100030000004320,102013201103314,100210020430111,100230104321104,100220100434342], + 110414243322032: [102031004002014,103140100210304,100024210103011,100002421031242,100000302211011,101212010301103,103103000121103,110441102112020,102020300201021,103040230104020], + 100024210400401: [110404121141042,110033200101214,100200141000020,110000402121410,110222422114010,114100100000120,100102004033200,110331101334024,100320220424214,112021140222013], + 1112010142121100: [102203104020204,102333001000101,100000131020201,103441224001010,101220434011130,100120201022022,110200400001124,114414012320002,100010000201100,111121024402221], + 1040010033001012: [111102214104403,100132004231230,103043334040203,102120131401230,110200302024000,110021340020022,101010001000320,110210020104031,113130020101411,102041210224224], + 1101002030120130: [110400234221021,102123140310122,114231044000402,101410030330122,111000144410222,100040001022000,110222241300101,101220300304400,103222120100140,112220024014003], + 140014320300410: [101042410301221,114201010001201,102304000210204,100030024300201,100020120101000,112143144020012,102220310200014,103231224012042,100110121040003,100040300102020], + 1221301004341230: [110441234224400,103100014031411,110000300424304,110104422010121,110013122130200,114020204102020,103121221400012,102022400211311,110242100010130,110142432042212], + 1023340021011110: [110411010000101,404130103212403,114124400000022,1104100000042000,1100210001041103,1200020222023401,1310001001103311,110432010304000,102022400114011,1042431100100100], + 1100022224000401: [110001332120300,102101211411000,110003000420200,110004014411012,112000120232022,100002320113100,112240200202201,101420021010003,100400122201222,100222110000310], + 232411410020040: [102002014000220,102203004042010,100020001041410,102410004024030,114402320000202,114014112302234,102141231343401,114112000004001,101004421020002,114003002301122], + 104012130021200: [102123220230210,101110004021320,102201230200104,114123042312203,103012101401220,103001334010240,100214324104012,101333201002122,103200021404423,102003114002001], + 1400001240000311: [111000232113233,100200013102111,100021210100004,103134204000000,100104113102400,100303404100220,102220202001233,100400040010104,113222010104232,111041200040020], + 120231220000024: [102403001342000,100102431021300,110200212041001,100033211230014,100001211040232,100100024234021,112000321112201,104122102100220,112034300240022,102213204040044], + 1010022120300411: [102104410220023,320424300313211,100430200104001,1341420023200031,101040020314000,1101003130212010,103220020131102], + 1020210001322101: [110130314400100,100032431030100,114001030023421,102223300202003,114400202314210,102022004010240,103012000100422,102023211411003,102202031002304,102240231110222], + 111203220301101: [102140020210421,102112401342040,100010031232011,110010002200040,102200024024022,100222101000100,101002111141200,114304104033020,103000001410002,100223401000042], + 100001111030342: [110214024430312,100011014100041,100212341003212,112010220224003,111110010022310,100200001001300,100012104313201,110212310000041,100040424310110,111301332200104], + 300001030003040: [102340221000300,100220124221000,100402002201002,101011014002032,102104101122100,102423114022101,112002010221020,101131201110300,111012030020003,114200404001002], + 1121000002032040: [110111001300044,111000002202324,111211010001300,114030020020301,111014014401303,103210001422303,100100000022131,112042111120340,100101141042243,100101100022012], + 1011120333000132: [110021000410432,100042304102210,103202000110102,102020440220202,101010010320112,100042000000000,112000021122010,100021111043012,102122101023020,110124041140000], + 222422401041002: [100032041021210,110004301222000,111202012222402,102001301120112,102040041320010,103203401400132,103142111441040,110104002010100,114142044120310,110220410000040], + 224230240230401: [102202000201220,102203011120021,114330432320002,101000424210014,102103122004211,103022230124332,110114002014221,102143002000204,114404022311000,102010010221101], + 1414104014031043: [100214230412031,102324101000040,114022024010120,102102300313223,110021100020000,114211032334300,114210204000010,111113312111000,102300104023040,100202400410110], + 213030320002110: [100220040142222,110020120040121,101040000301210,102130034023112,103100001422200,101330120302103,102111301402121,102010310211212,102210104011024,110042012002104], + 1120132400200010: [100000430122100,102000231122032,114020002212200,110131111124000,110120001000140,111402002210300,110001202000001,113004020134131,102304321002120,100101020403013], + 204033200000310: [101001040340004,102424204043100,112022334022101,101011324004222,100300211000020,101410401010030,103210241422022,103240001403000,102202204040220,102121010212140], + 1000202020044010: [101042410301221,100102024100020,110040344210011,100003320401100,100020120101000,112143144020012,103231224012042,101000001001104,100030301030114,100110121040003], + 1000100110113302: [110120144200000,114022412330004,101200221022044,110241112020204,100002004104004,100014204201000,102103321411004,100400001001300,114113000004012,102140114004004], + 104304111001104: [102300401000244,102340140222011,101043004000042,100001404100302,101011241140401,102400131400312,101101014004001,110000022121001,110030111010220,111201002222130], + 1044020201104204: [111030212113431,110001030120020,102001111011201,103222004032000,110044320441241,102233034000002,110410122010102,101122404022022,112130004021000,110311110410340], + 1000402212000012: [114042032210200,114404220000142,101100214003002,102410420230111,100404342201400,114440210000102,100000120412021,100030101041442,102210020200021,102121100212002], + 1021202231111001: [101113140334114,100030310422011,103041020101400,103113224004201,111300402200003,114141024004011,110022341300320,101400002040042,103010101241110,101002101141202], + 1222004024222012: [110001332120300,102101211411000,110003000420200,110243234240200,110004014411012,114110200212210,112000120232022,102041220200010,100002320113100,112240200202201], + 100011300010020: [110002412130400,112011010223100,112110001102104,110140304404000,101000011003140,110202022121042,110000121102001,112301031103203,110222431302410], + 1001033001300202: [110001332120300,110003000420200,110243234240200,110004014411012,114110200212210,112000120232022,102041220200010,100002320113100,112240200202201,110020321120011], + 131120124134240: [100024000110221,114130014001202,110010220103020,111001344400222,101021204010011,100404410022320,103012101410102,111000000000411,102131304003000,113030232400401], + 1213101110133100: [100100021040144,114101404004011,100102404100430,114142044000010,103020241402220,100104020022212,102023110212012,103321124024003,100040010010104,114210134114310], + 1443101040023020: [101210010304011,103120400210000,114144004124200,110011424414202,110234012243001,110000214202000,100040011023003,100123031023104,114223212320410,101004020312432], + 130200411001110: [110210221300113,110304014433122,110200004243223,101000204001222,102000010200200,100002330412031,114020042302142,113420011011140,110020122000000,112020402001012], + 1142220430002010: [103300121401234,100122200020013,100400320033201,110011402100202,102331104112002,110121112010004,102020131413423,114132002200241,114013012240011,102330144110211], + 1004100220302101: [102000001132113,103020200141000,100120010421220,100000201041300,101100300302102,114011200003102,101020104000040,102432101112141,114412142320040,102100044000000], + 110210033021221: [110011414240022,102202310203222,100042001020203,111142010020301,100010044300003,114130210231020,103301410110110,112114324040000,102124031023100,100204104320231], + 1000040200134210: [101200101021000,103000024014022,100040404102010,101020404210020,100001001021002,114200104001010,114040414014202,110002110021301,101032010322010,101000100340432], + 101021323404101: [110130314400100,100104010021241,100032431030100,112102024020402,114001030023421,102223300202003,102022004010240,102102010214442,103022110142241,103012000100422], + 1001003100310112: [101221020040220,110120144200000,114022412330004,101200221022044,100103104302044,101041030320401,110241112020204,101203121020430,100002004104004,103130021444021], + 1140002220010104: [102120031140142,101021204010011,100404410022320,103012101410102,102131304003000,102220220201011,100222044100141,101400000300101,102000110222120,102134144003010], + 1403211021421001: [102402124022000,100200200412034,102232024002401,101012114000304,101102120301114,102202141120400,110120224221100,110000041322002,103444024001001,103122404000344], + 100100022210230: [110210400114203,101101300010301,101122200300011,112210201100012,102120200221403,112001122302311,101001211004233,102110314001121,102303011002000,102314100240010], + 1000100201441100: [114101024120020,102004011440212,100000001021013,100011204300012,100101234330123,110024000432310,102012101443110,110032220022103,102102104000102,102302340241312], + 1010012300121104: [100002200100100,102032022000041,100020000120134,110202001212002,114002420040210,102342022000024,114000222330121,100113021020101,100000014312111,102203214040300], + 300300013100340: [100324140141402,110000410001034,103204301402123,110022002120332,111110230014001,100210200034304,110102111204210,100301101000021,102120244004000,110020140044140], + 130000131310000: [111002100000102,114021010040140,114222302321101,110014024202014,110220130100010,100020011030330,102404221402210,110203022032320,101300004233220,110444031144430], + 222100034100230: [110102042010220,101020124000413,111210000001101,114013400011030,101020111030400,103004104010210,101220024041000,102010300201414,100202200003011,114330432320002], + 120300021320132: [100032041021210,110004301222000,102001301120112,103203401400132,103142111441040,114142044120310,110220410000040,101030004010034,102201411100212,103100104000121], + 1031012001013301: [102004204041000,100104341010424,100002320411400,103142210104020,114400240003003,101022001002030,100002104104001,114000212331142,102321014111000,101104040302120], + 1004011201103433: [100232214222204,100040324331403,112104212010101,100001104201201,102300221002020,100002101020010,112010202000202,102033024010010,100004001000211,114230112330402], + 1022431140324140: [102133011413110,114022424102243,101223020300040,102034324000220,102022400203211,101230020303000,111340130010314,110200422121211,101214240300041,110214220002020], + 1240111020121000: [110112102211042,110431442110400,114011120021012,100100111041320,101420010300310,110000004210112,102334001004100,104100001240034,111200100000400,111321424123422], + 1001200214012002: [110001202003004,103234101420113,400013004332041,102114101444001,100022121031020,103140024002140,101004224000300,102141010230201,100012324201224,100020210101002], + 232001300103214: [102001404012100,102122214131011,114223204100010,111041202200140,100023031000024,100020004101012,102402000201011,102311011000200,114220000000024,100013040100000], + 1014000403002220: [112200102024122,103000034003300,110302322102041,101003414040023,110202222130000,103122214003002,110012102130001,102010010200000,110200300003210,103110034001104], + 100101301003230: [112000001123004,103400100131022,101004141000312,100030121043301,111034332202000,114300014030310,103304401402003,114142102200122,114010234030120,102110004000012], + 100002000042001: [1300422220310121,120032010212320,1023422111011102,411001103222300,411311131413022,1220101103414143,320440200013001], + 1034342000020200: [110130314400100,100104010021241,112102024020402,114001030023421,102022004010240,102102010214442,103022110142241,101002024000400,102240231110222,114023142202040], + 1123410221410224: [110401140004202,110040002034100,110044020020202,110301311303102,110201434430102,101002020342002,103200001420012,101201021021111,103210000112442,114020132334212], + 341141400041030: [102104004021010,111221000010010,102320001000230,112211222041401,102302021000041,102110111410032,110011021320030,100402214322223,112002101120233,110403412221122], + 1110340032032312: [102001030224000,110224032120040,100240404100140,101201030301210,100340230424131,110001004210440,111002010001321,102042404001104,114020204020041,103213101421223], + 1124000110100304: [114210200002420,111131414401020,100102030422220,102223100204131,114300420001431,114021114021002,110100021200402,100030000413102,102323104112200,114001212300101], + 1031001004021124: [103203201100220,100021224313320,103420134020000,102100344000130,110223200102231,100020000100311,112221010203222,100304311002100,102112201022001,114110000210010], + 101442000044002: [100000024341200,103011004040001,114010000040102,112022230230101,112031002000022,100000300202210,100412000433214,100210124030101,111200210001022,110112130003104], + 1003221221100420: [114011130043110,403102030210220,102122014134004,102122011343402,102040032400410], + 1441220003200110: [104101321240004,100020204211040,103440104004241,100022404242424,112313000202012,103010144014002,101024414220000,101432221011020,100000234202000,100023221020004], + 303001001012002: [100102024100020,100003320401100,103033044023040,101000001001104,102430010202411,102140031410024,100001301020220,100000100010002,102240000204030,101023004000311], + 203000024021000: [112213000200301,100003224334120,110204130004030,110202120003032,100322004314021,100404000020012,102343301100440,102410434000220,110110440020002,101101000330302], + 101000022141301: [103111001422000,111244302220204,101400004022100,101114000332010,112112211102024,114031212300211,102013110201200,102111022001024,103210431422030,101011311030141], + 101220210030110: [112000124022430,100212030412303,102302120210122,100400300013000,111010012201220,101002104002020,100300304101302,102220211302322,111322300013200,102202001300342], + 100134224400001: [101221422120021,100001000002210,100400320033201,100004130002301,102020131413423,102144012001113,114431110001011,114243004003002,104130111240040,102422314024300], + 1030200430101420: [114100300002413,101403204021000,110400012110211,110102141123102,110130001303042,102121000201002,102200201123212,102122320204201], + 1004240010210020: [112210010201431,102102030214401,103100024002220,102021420233130,111130410020021,100044004210004,100320104321221,100003104100240,100112101024230,110010024420000], + 1113023000401222: [110020120040121,110000100022040,114004142244000,102002004012310,102130034023112,100302304310204,101330120302103,102111301402121,102010310211212,102210104011024], + 141120000004300: [102242304042410,102000201131020,1010120030012200,101024411001024,221104221024023,102123332000002,100202211200032,100142410401000,102131120310242,110002304201031], + 1110302441024024: [100114234102203,114023224010002,110020320412002,100300301002020,103040424010400,100010104210010,112203010200014,114400444140020,114203004113000,100000404100021], + 1020020042103010: [100002100100210,102420424042020,100010001032223,114321002320001,103020031403100,102200401111200,102000430221040,114003104031111,100102020411200,114221030000011], + 1100221400010212: [101400004022112,103002221400000,103110020210000,103001010101001,100022141030334,111020142144200,102100201414400,101313201003110,102303001102431,100141334301022], + 211040010200200: [102424204043100,100113220020101,114031000022030,100300211000020,101410401010030,103240001403000,101202201021310,103044004010022,114130020222342,100042034202031], + 1011201102000201: [101210321020222,100022110021010,100122044230200,103423000242341,103121002402240,120412001020102,101140304001120,130300211110200,100201202200003,100141000110131], + 1140412010102012: [110104112010103,111102004100101,102202414041044,102140014001101,102021100220101,100230120001003,114000040010421,112042110220004,112203221102231,114022400020320], + 1112000010202103: [114020010030200,100004402212111,104000011101040,110214202044002,111111000020303,110020041012320,103123434002000,111000214410000,102122101120300,103210010100241], + 1123111001000240: [102100014132110,110232232034400,100024214100000,101013001000203,100104044100201,100000404301003,102100001400002,103202101404021,101000104000440,102023401100001], + 122244000324122: [103224310130411,112210400414000,100102101220123,100402210013023,112200302030311,100000001210103,100202141010030,100220000432000,100000210112011,102041320202034], + 1020010442013204: [102101004000411,114221312340014,102434121112224,101200210300413,100311204312442,103000020100131,101211204201231,103210021401223,111130412210000,100011300412123], + 221230142003200: [103311011404143,100000014211030,114430104142400,100220121003120,103220114040342,112032000201314,114021034021244,100002000120011,102110101141003,114001114121130], + 322300220440000: [102442211414022,110122001010214,102101204000010,111231012220013,110022300420031,114230230000123,100101220101011,110000141123103,100222024320003,103323001400013], + 100002020002032: [100030100410121], + 102443031042202: [103241104032021,100020114101410,111221222223134,404220140010113,1244000013132404,422002310200202,210111004010010,304130030001002,112102014020004,104112143430303], + 223002221300001: [111304340002030,100100111044040,103140014002031,102024102020000,102224241110003,112003020220120,100043024210301,102014001130100,114022100010000,114321004030021], + 102302024000021: [102000001132113,100041000010302,100110004103122,111321314133000,103031300144042,100120010421220,100000201041300,100000111034100,114011200003102,103132114002002], + 224011130402140: [112142301101040,101000130320340,101100000330120,101214440300301,101121100332142,112401314040311,102011004013000,111200122222334,100220124221000,102301024113440], + 1004100002111200: [103122114004113,102242301122200,110030110122402,102143432000102,114001110033210,102013120200110,110120011014412,100011111022300,114032300011302,100234004033234], + 1240310001422000: [110300000402020,102110221412210,103330421400224,102431400204010,102112042004203,114030100040000,100120431012000,112210204002124,101023410321122,101022030320100], + 1010202012241000: [110041030411301,103301210142043,100002024200142,100400014321101,110033041200104,410110432000414,100000011020021,114002102300210,100034000410212,100304011002220], + 1041101330000221: [102000200220320,101322410300004,114101004100000,101010221002100,112020104002142,101303104220020,100021030410001,114210204110100,100024141022000,101000010341231], + 330304014040400: [103212014020132,101021120323020,100102101000203,114111200034310,102001111412134,101032201032000,103230040101112,112212002031124,100101001013000,102110234020204], + 113042113000040: [102001404012100,102302200210010,102340120222440,114223204100010,111041202200140,100023014313010,114021040010311,100020004101012,102402000201011,102311011000200], + 1031010414000000: [110100000124440,114233242330032,102012004002430,102020000204042,100241101003430,101001224000033,100101244232013,103000301221001,111020122111214,101012111021003], + 210001023422422: [100020001041004,202421100022041,102100111403011,1000042010002402,1100001420031333,124000002040110,433020311213122,1321202200220200,130030004001124,100040220123030], + 111030413000240: [114012012330203,102100020211003,100000214102101,103100124003243,102033200222311,100100104102000,111204302220322,111022434120140,103021024022122,101000220311120], + 132000022100131: [102110140224010,100022121031020,100103240011013,100020210101002,100042420003120,101020120322020,100024321020243,110112410431040,100100031002000,103000244010320], + 1002022242030141: [100022004302311,110101001301201,102104104001020,100011314203014,111133104102443,110041121310100,100420230030100,100402000022324,112332210202010,100210211211214], + 100233100400000: [110220301202400,110210024220020,100401424300314,103101001422002,100040120000031,102002104011244,114200142324000,102100041413022,111140122114101,100012000101100], + 1040012322011210: [112004001122300,101301124222004,112204220200011,110013202120001,100230040410200,103210004031201,100030300422112,100033001230040,102002000242023,102200014042201], + 1420000112022344: [111040120022202,102141000230040,101001300340322,110100224200101,101210242120124,110014342002102,102031021440000,103040201222041,103021424001214,102100204000340], + 1003403140221202: [110000212000300,100000010202003,114234324112000,102400001110102,120413040002400,102300234110002,102210014111401,110000401310201,110001004413010,102303104110202], + 1002200202000230: [102012201321104,101002011001110,103012301401041,110043034212101,100022130100210,114442140003011,101001301000011,101200034044124,103042224001110,102110040230322], + 220102002132202: [110342022000001,110100121224222,114403000001001,112311212021024,100030030422421,101120020304200,102020121321033,100000421021000,114132212313220,102020004000400], + 140030100240101: [100420244300112,101012001030010,102230121123103,110202010012201,100221440000230], + 1010240402000022: [100004101032202,112100002011214,114401022311200,114020004020300,110114130114210,100004321021120,100003040102022,102300420220003,101400211012100,110012112003243], + 100030322102010: [100000211023020,101230042120212,110301022104110,110014101200004,102120441440200,102021000220100,112302302021203,102213224000403,100104024300122,110102142040030], + 220112312420330: [112400104042431,110032412204130,121230313021014,111242402020001,101032401114024,110314040011014,101400414021000,114101012201420,104410222102000,102424040202123], + 140333200401210: [101041441032123,112110200433212,103001020100110,100030041220222,100022004203010,101000044012401,103312300141010,102000300220020,104130230010032,101201300300343], + 1000013100021200: [114210200002420,103010000100410,102203240202202,111131414401020,100102030422220,102223100204131,114300420001431,114021114021002,110100021200402,110000022203101], + 130420120232011: [100000004102121,101141104004013,102303000241200,111120032212032,100012014202201,103242024032020,112012000220000,114002100044002,114033012301032,100220020410020], + 112002232431024: [110000212001040,110020000431012,110034411301222,100132044303043,112002220220201,100402020013040,100001140200004,101014121000220,102120231120442,110021221012222], + 210400430020223: [100001230201101,111102012220413,101101131132022,110010102132024,100010100000042,104120211242040,112220104002000,102223004042102,110410312121010,110330130010041], + 1044210401142120: [100200440031411,100112224301402,103310101401010,111200114100011,101322224220202,112003000230001,110002120141023,103021000124113,101212020301403,114340022321132], + 100114240104301: [100232214222204,100040324331403,112104212010101,100001104201201,102300221002020,100002101020010,112010202000202,102033024010010,100004001000211,114230112330402], + 1021000411012432: [102322014113341,101022104001221,100040201012040,110021422000000,101120030330110,112021004003303,110331012224112,114100222310230,101002200301130,100011120000004], + 1001040400024411: [112224111100141,100040134340044,103030411422014,103043334040203,110422201312402,102120131401230,110302011332024,110200302024000,110210020104031,102041210224224], + 111313004403400: [102110111410144,100031010010121,111141012240014,101041104222000,102203044043244,112000202310100,101012031033100,100400030013102,110000122101140,101210000302442], + 100204240122101: [100440444301004,103304014020032,101221121020230,100004110000301,101310004223223,114113004120221,111210402244301,102100011341140,1120022020242320,102320231000001], + 310100212100102: [103000144000400,100110011002040,100140011002400,124001030020034,103214000212400,134312110020403,103130121241210,124002000123111,100041011030000,102010121122221], + 211420010120301: [100002100100210,102420424042020,100010001032223,102200401111200,102000430221040,114003104031111,100100000422320,100102020411200,102100012002000,114221030000011], + 100000010143230: [111231002242010,101010211001011,111220030010210,114042034104243,110123111300000,100004030411141,100412030034000,114000214012010,103232114040140,114010002240111], + 100000240303020: [100020220410142,100222311000201,120202201010210,112042024000020,110022100044100,114400200004310,110003000024101,102020031103041,100003341032400,220202121014102], + 1100302131422112: [100041000411231,102011001320032,102140040210040,114004000040100,102010031444104,103202300102400,114103200002100,102410010201202,102202244040132,100000001021001], + 102122001241041: [110001112031124,102214100240020,111012114400321,102114001122300,102120044000240,112100012011413], + 1100310201402143: [103100030100010,101400004022100,114031212300211,102013110201200,114023010024000,102042321440100,102300121004222,100042000102010,101401101012402,112000230220102], + 1002200241040201: [101041301000320,101210004011003,101230044012202,103242311400421,110000310134014,114000012334010,114302200002200,100200024301301,110010204412200,111202010001410], + 122300110322110: [111121100010021,110310034424102,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241], + 203110340210130: [114011220041204,112022040242001,101043121111400,101100004022130,103123314002423,113004022020033,100100121000430,100421110431421,110030042203103,112020004002100], + 1002000411204201: [114210304111002,102030010222333], + 131001311001222: [100110114231201,114142204001320,101001020310040,112202104011100,101103044000242,111211030000211,103012304042020], + 100232041430001: [100023104312100,114330144030100,110120314220210,103102201422301,111303330011200,102310401104120,101100304000032,110002142002040,112342000202234,112412104042222], + 102043213000102: [101221020040220,114022412330004,100103104302044,102020004000014,100400001001300,114242410001010,102100200210002,102000220220104,102003321120000,114202044111100], + 110440401004130: [102430231400211,102004021102101,112002012030102,114440240003000,112120302010202,100020010000104,102124200204223,102223211121031,110012020042102,110200012121210], + 114312003000104: [114400344144312,112120120200440,112210040204030,112213110411211,101030400314212,100103114003211,111140014100212], + 1000100012202232: [111000022202402,100430211011410,110010340040012,110014032101430,104421312102244,114200322333401,103010021422042,100000001022401,112312330200200,112020004000202], + 114120334414202: [110041030411301,110001041213031,101110044200100,102411000200000,110414300030001,100030020011022,114100122342002,111202012222402,110033041200104,102000221442214], + 240300330410011: [101041010324010,101000004210020,100011230101432,102210314111120,100032300010000,114140404123402,102130031410200,101224111004040,103204231200203,100010300414000], + 143021320031002: [111022412140224,100212034221414,100222100402024,100121301023030,100020224310403,110000130020003,100020424102200,100014000022201,101121401110420,100200001211010], + 102103030240101: [100223214121011,112024121130304,100202221212300,110004022000404,103020210101200,110010012102144,101020200301303,112000111120040,100402300022230,111004012200303], + 231122344112000: [100011314203014,100210211211214,100002134303110,110041214411012,101000101022043,114420240001400,110032124211302,103022004000030,110211122020222,112400122020014], + 1004212204000210: [102021010243000,100022041024214,140021143000030,102000021120110,112300101130013,114420304140020,100102031001102,102200000200400,101002301002124,112011004023221], + 121140124341410: [112113214020100,100000130013400,103224041400220,100001321032243,102104244000010,103113010102100,100110301022230,101122100331113,112002040220020], + 120041121012002: [100413011000000,110001202003004,103234101420113,210330042103020,103202004031314,422202100011300,102114101444001,100022121031020,102021211440022,100024101020044], + 1420410200222041: [102010004001300,111223042243230,112122034041020,100000030022004,101202010310030,103001024020104,113001202210003,112212342010400,111000304441102,111122300030202], + 101441103000032: [102040431121110,101221020040220,114111100021420,102212000200124,100300310140241,100240134323001,102141212000200,102042000222002,101203121020430,100030010102102], + 1020322230020101: [112113214020100,103300344012201,102010202004402,100000130013400,111130312211003,103224041400220,100001321032243,102104244000010,101001010300404,100201104224131], + 130030010304231: [110011011212100,101134030011000,112000244001222,103220211421421,110430014221230,100044130000101,100102110402220,100021041031203,101140204001010,111300000014233], + 1020013022000001: [101210320301302,102100221340112,100114104101001,114002244103320,101023221000031,101400014040400,102012034000402,114221004002212,102100122002001,101000011021414], + 1043332020010012: [110004020020022,100043010120010,100123044300022,114322024034312,102143432000102,102040010200101,102200434012013,112000301122111,100021301302122,114001110033210], + 1044042103201010: [111101122102222,103000114001000,102242024030234,100003344214000,114400300000221,103104024000023,100002104201130,110120204222240,110043014410220,102322420210320], + 101230231324114: [102132400232131,100114234102203,114001232300102,102323324112410,114400112311040,100422140030210,103000041402003,102000141133020,101141111100022,100001021003113], + 1000220030201034: [103010000100410,102203240202202,111131414401020,114231020001120,102223100204131,102340202000001,101201410300004,110000022203101,102323104112200,111222222244101], + 1030401222010020: [103122020213112,100104010021241,114101100211240,103012011434022,101032010342004,114102102344110,114010002300003,100112110020301,100000004102124,100022301000112], + 122220103141240: [101020204214020,100131144232400,101001004220021,110232241101002,102104101340430,114020020001014,102201401001104,101003200300401,114132204142000,100001024314010], + 1001143144011002: [102102241341004,114110242200201,103002020101431,102020431101132,101404104000404,100012104210032,100300021000040,112000300230010,100001024102120,111100022244144], + 1004121201021313: [101221020040220,114022412330004,100103104302044,101041030320401,102141212000200,101203121020430,103130021444021,102100104002224,102020004000014,100000211023014], + 1121000304342022: [101003410300310,102020114003042,100220001203033,100023121020104,100401404302031,102400024020302,111101114100040,102401124020410,324200002000200,112400224011021], + 100031211130430: [111001440020003,102001000212142,110200020010003,114121000002140,100002214100100,102120104003011,110123042010000,102120402000014,102000200210032,100041000100422], + 124020130400020: [112142301101040,101000130320340,101100000330120,101121100332142,112401314040311,102011004013000,111200122222334,100220124221000,102301024113440,100033230420102], + 141210102200030: [102100001001020,100143134233402,120011202033000,100003221233221,110021302100210,100100000004341,112032024022220,112002204021024,130342130221000,110032022014300], + 123012411210140: [112000112000031,102123214020000,102022124012030,100143220410040,114002320022312], + 111043020140033: [100040401020114,114202400210000,100302014210100,102102010214011,100043111020130,103112004004201,100122210402412,100002031210114,110213300002210,102402200200000], + 103320000134013: [102203004042010,114203042330220,100020001041410,114004014011110,102410004024030,102032012000101,102102231400111,114014112302234,101004201001232,100002020101023], + 120000220101210: [103034010121101,102302200210010,114003344011001,100023014313010,100002301021040,101014201030204,102411201112404,102100011320200,101203001010111,101000314000042], + 120131011033211: [103300004021200,102122214131011,100023031000024,103230134011412,100012004101221,100020004101012,102402000201011,102311011000200,102021021101204,100231020102202], + 230000104002204: [110211004240041,100001140200004,101014121000220,114000002300010,100211021201202,110220212104000,102141341340331,114234000000121,100042011022122,100011024104002], + 1112430020203213: [100121214300011,110000002000322,111020330020323,103000224010010,123004131002200,103001014010032,112400142022120,112431022020401,102411024022203,112220402021203], + 102211010302004: [110420301340222,100024000010302,101103031103004], + 112120110300031: [110033200023234,114034120024020,114202042330012,103024110101112,100120244232122,111434000000313,110202000012302,111010012202230,112400100203420,100000004303002], + 1003210001202113: [102142221342202,102420000202033,101012400343401,100020101020404,100002411021201,102110010210330,100012020410400,111111102240001,102122111402420,102001041100103], + 102132043014311: [101042410301221,114201010001201,100030024300201,100020120101000,101041404002420,102220310200014,103231224012042,100040300102020,102400110230001,102101011342100], + 100101221000304: [114021010023030], + 203140024002223: [101020000320011,110400014223001,112040222311040,100100101011200,114214220001140,102204404111433,114040214101433,103144001420031,101022220322100,130040244231421], + 120112101203144: [110201344402000,102323041000400,110020212130021,102103401440120,114300140000220,100124004100122,100002421220110,101120100303302,103000210102212,114001124020022], + 224114322002000: [111020232200302,110130201011011,103120214032200,110001020120322,100100021013214,102312034020114,110431140100000,100214424300324,110014000110222,100110040031200], + 1121024000230231: [101140130013320,103124001420200,100204210031132,100023001042200,103224034003141,114202022320120,110442122023340,110020240400120,101022044001032,103101404000040], + 320003121333121: [102001301120112,103203401400132,103142111441040,110220410000040,101030004010034,100002111020202,102001104001420,102303031001004,100121004300001,100000341201004], + 1010020401211020: [111424104420210,103202421200002,101112140303013,112212200204110,102302230241114,111202202202000,111113200032410], + 1003022113040001: [110210134244100,102121041441000,114102022200000,110233010002020,111203034103022,102101304000012,114020202241323,110004402131000,101240024012131,100020114100404], + 131101000214201: [100004214100234,110402410002000,102001011442200,100324200110130,100342120144000,100100031003220,100200034020100,100000041021200,101200100301000,114402014140102], + 213303013002420: [110020020001220,104120000021110,110102030403010,101040010314220,111211114421220,110000000011102,110400000004402,104101420012000,110132241240004,102010411120012], + 1000032140003300: [102110010210104,100040004340001,100021234303000,110420020103322,103100204000430,100034221043231,101140030330020,110030242131210,100340204211100,110142214201120], + 140001010421240: [100003030003020,110410000104042,100014014203233,111422100034314,100000040413000,100001034310012,102030414003000,121310232003222,110011300143002,100220021000033], + 123220031302140: [100130320031042,103110021442200,102010004040000,112433112020200,100042001020203,112221200410000,112023032000020,102000201101332,100111304300020,114132420004104], + 140002122110020: [100414204320344,114012012300010,102141220210212,111202024134001,101000004003224,111302120011012,100002314210021,103101031440430,114220102332012,100000211030342], + 120220000202013: [112411140200242,111201202221200,101001201000220,111123002210402,100011004203023,103001241432010,102022020220023,100110001000040,101010020304020,100010001043003], + 100111320200130: [102120410202221,102203031112000,111240012241220,103002001420012,102034031324100,103001404013000,102102022002404,102310320222212,102300041004030,102100024000422], + 1022104112013400: [100024234201100,102113300230021,100010044310002,130000420243230,100232104120201,110112204224100,102212234021233,100100341202102], + 1120000410100100: [102040431121110,100400002201113,114111100021420,112024212301420,102212000200124,100300310140241,100240134323001,102111024000402,102042000222002,102001011100100], + 130001004011024: [102010124012100,114131102312120,102000111101030,114142022200000,101102204023404,100440100030210,114202110002002,102110004001320,114202322324020,101403100301000], + 1100122212200242: [100310304310342,110140044401202,100010041031020,100042400001023,112402000200101,101010020301243,102030001103000,100040021031201,111010130022401,110224120012221], + 220022341020003: [100310304310342,110140044401202,101300124221002,100002030410210,102231031123103,112402000200101,101043314210310,100314420140013,101401204040200,101010020301243], + 102102100000043: [102300041004010,103000140101310,112400104044001,102310204023400,103111240223100,114401010001000,114001310020023,101113001101020,100021401020000,100203310430032], + 1142324213123030: [100033004310000,100404202200440,100243220432021,110030120020044,101032004211321,110223100002121,114330004034210,100132220400121,110102004200021,103001121222240], + 1012100420144031: [114420112320212,1012100023110102,1020343020202224,101012041142400,130001344030034,411204402322000,403240003100140,140441120210201,203322214210110,320440130020000], + 124120201231200: [100222004320102,100110004103122,103020200141000,102414034040100,100120010421220,100000201041300,100000111034100,114011200003102,103132114002002,100412200002013], + 121130111100011: [100021000104004,100002200022012,111140204103210,140004010302423,114200320003120,100200113201000,141220400002200,100044231103400,100411033204412,110000001210210], + 1420230201001033: [114011130043110,403102030210220,102122011343402,102040032400410], + 1000141230400021: [102102241341004,100000041020230,102030011324204,100001024102120,111100022244144,112221201100134,103400304020142,114410012311040,100022030101111,103101000212001], + 1430002230014000: [112303341100100,100004024311221,110300440000022,100110101000111,101220141010040,112033004000010,100113310033004,110401220400210,101222240300200,100124014100400], + 1041230001404343: [112142301101040,101100000330120,101214440300301,101121100332142,102011004013000,111200122222334,102301024113440,100033230420102,111110004402021,100000030000001], + 1100031214442010: [100024000110221,100110020031042,110422102110221,114130014001202,110010220103020,111004100022110,101002201140040,100211000412142,114040210022000,111001344400222], + 1011233114410200: [102010020203010,102033021130021,102001241410312,100000121042240,114444012310100,102330021000131,110400240002411,114432422322332,102000320222120,102210241122001], + 101002100222010: [102300010242203,100020410410021,102400201404120,101410121102004,102402224000010,100001104012111,100011320420210,100302014104012,101110101110020,103010200113110], + 231240214120003: [100430021001320,111410210001002,103214301421201,1000001214032041,101023020301100,114000332302320,102100221341001,100040004304002,100011301000021,100100001040210], + 322244041332122: [100024000110221,100110020031042,101301014221122,110422102110221,102102204022310,114130014001202,110010220103020,111004100022110,101002201140040,100211000412142], + 1202020010240120: [102142221342202,102001200221011,102420000202033,100020101020404,100002411021201,102021014012210,102110010210330,102244221114031,100012020410400,111111102240001], + 1121040002000003: [111220002220100,101044120322004,110114410003233,112144312011433,101410044021332,114020204101200,100013031024000,102012014002001,112302412022221,100140014100401], + 1100340100010440: [112142301101040,101100000330120,101121100332142,112401314040311,102011004013000,111200122222334,100220124221000,100033230420102,111110004402021,112204002031203], + 130031024034001: [102020200223310,101001400301113,100002120200101,102014111102023,102432114041004,102100431342023,101301014220002,101012044004042,112410300200001,100021201020001], + 1134031014303220: [100001141221200,110241101203132,103001001422110,100300200420220,102111320321320,101020431000212,100302120421003,112202304014001,102020341100213,110421120403200], + 1031322432311201: [110000104200413,113141002412032], + 1000000000420104: [103100301242100,100140211000041,100331204212000,102001204011033,110121102212120,114112212343020,103000210111110], + 200412214103301: [110001332120300,102101211411000,110003000420200,110004014411012,112000120232022,100002320113100,112240200202201,101420021010003,100400122201222,100222110000310], + 1010132020020210: [101133001104410,102301001004020,1100000411441420,1002203010011112,402001100011120,100020321030202,402202000003002,1113101130040010,1300120104000102,1324240003020201], + 200441400202301: [110321031234422,110302100111410,100410434302212,102023001440404,101023014004000,100020010101201,110412042010210,110010220121014,102312344020020,110124411120222], + 1010101120402041: [114401200000003,101221000312044,111001314111000,110323142102300,100040120003030,112111004022140,103110214000303,100104001013112,103112204001240,101013410304010], + 1404413003142302: [112020200242131,110240024241203,112432120204400,100021420120102,100104041023201,100022214101010,110001340112402,103040421244210,111111014402340,102301204011320], + 122102003102133: [100014401210011,102323304112140,110021410020203,110411044221200,100003034100001,114200222340000,102000010200014,102110402004000,102423031402210,101000040343001], + 1042123221023212: [102132400232131,114001232300102,102323324112410,114400112311040,100422140030210,103000041402003,102000141133020,114212344000432,100001021003113,100013001040200], + 1430220101402142: [102432004021410], + 1420342121202410: [100004204302330,110000100422111,102341014010003,114132202312102,100004400100414,101013024002120,100041244344014,100021110200330,110322110010000,103302034020140], + 200400224202012: [100133214230003,110240040001040,110100401322012,110302014420400,111401002210202], + 1011101201024400: [101004014003121,111212014101213,100012020022402,102313324114200,112420124010230,111122020033401,110111020032001,103001230104021,110021102010001,111310000001341], + 1121204432034042: [114200212322001,100401210020002,112210322040121,100402042200000,100010111022102,102000224000000,100002104302110,110030222130000,101022440300020,101402010301000], + 1001000021034041: [102041310200042,110301030010140,104100002101431,110221000111302,101010001002000,111330020002213,102011440201423,114011212320331,100002204310140,110110210011002], + 110023042240131: [102100011410300,114410204142310,102022000213102,100101421010233,114423414113030,111022100022132,120022141000020,100003001040112,103103001422442,102000404001100], + 200022020001311: [100141220000211,110042202002303,100320011001200,110002002200300,110443002010003], + 224401100220202: [103122114004113,102242301122200,110030110122402,100011111022300,114032300011302,102100000313104,100234004033234,101222221020440,100011111021031,102002204003400], + 1410000332231040: [112012012002100,102401024020221,111231012242301,114444004140210,102220210203210,100000120120001,110031214200342,112433204041220,112120304021020,121000442023140], + 1020202200301343: [100033114200011,102201130200131,110100111221242,114020202201002,102100300233312,112002024004122,111021044400403,101231020300003,102203210201342,111201002200020], + 1043210210001214: [102300120220103,101210021011110,100001424100120,100020100200010,101020200320000,100020114202320,100400000033202,101131014023031,112102400204000,110003204210204], + 1102032121202033: [102003224011000,102304420211002,110403042110030,100101400000132,100032424312011,101110301040312,102204010204023,100220000432400,103011024000103,110100104220021], + 220024203101002: [100440000030040,100023101001004,102001014013004,101201104040034,102101000233302,103210210100210,101013101033100,101043004211000,112340340200112,100001000010010], + 124100032040200: [100012120201211,101410044020102,102011014010000,101420031011004,100000014310020,102111001341321,100022204300002,102202122000302,112100222300311,100321100443000], + 140222200013230: [101302134233230,100000130010033,101030404212000,114102224000201,100022021041122,100020001042002,100013011020311,102103331400000,100120041020012,102012204000242], + 111100234220320: [101210320301302,100440024301100,100101041040330,100114104101001,101023221000031,101400014040400,102012034000402,103341124011404,102100122002001,101000011021414], + 1000100300110004: [111101010010203,110011000022102,103021220104200,100004104210221,100021020104220,102202410240103,400014404414011,102120001343001,100112004101222,114202332330220], + 123221213100210: [111124004101012,104102040011120,114103220220104,102120004001310,102430121110340,101021204000200,102020121102120,112141104020201,101200111020111,110001200422320], + 103034201102242: [110040011323003,100001024201214,103041221412320,103433121201311,130014300140410,110113211301114,103000044041243,110123210022200,120000031300010,121012002003322], + 313122200220030: [104103201240410,100011001021002,110000141012003,110112301300000,101040100004242,100300204010001,100011320043322,102204100232030,110110012110224,100003000100210], + 102102110004001: [110330400010040,100101231004020,110010100022010,111000100012002,110022140120012,100143040411011,102404404004104,114002202302000,100034000000002,100400100031022], + 110220242100124: [114000034010043,121021032342113,110220210110004,110221401304401,110420001101321], + 204200114002004: [100002121043000,100133204300040,102001024011010,114021112304224,101302321002232,101010120320311,101201101001302,114030212300112,100020301020200,101000000323000], + 1442041201011210: [100032041021210,110001041213031,102300324010203,110414300030001,102100142002204,100030020011022,102040011121100,111202012222402,111322234130000,102040041320010], + 240011033032001: [102331021100100,103223014033210,110001311210334,100002001211230,220321332020001,114410102321111,114012002212100,101100234021102,114203110001031,114121104101103], + 320202320301230: [103041220111410,101100202130022,102004201032002,114101012343012], + 234000101024042: [101012000300043,110422011240010,100010004101244,110100012142010,102011114001033,110030042003121,102120001340020,111023020021014,101010001002102,100000000100221], + 124100100111212: [110010100442102,114040002330340,102130014134000,100010114102101,100041001020232,100003044241304,103010014020010,100434044100040,100004204211224,102304200241010], + 101111020002300: [102310000222133,114111000222110,112034040231012,114104310000002,100101220021240,102220011122100,100001001034141,112013032002214,101404441100012,112123102010143], + 1021210013303111: [110102401201204,100212030414010,101400004022210,102031021441200,102300031004340,101200020303202,111340300010010,102013224003020,103013020123142,112402000200342], + 110000132011220: [402000401204030,114124020222032,100140201000222,110110000004210,101400010303002,104200202141001,130030220200012,112200110000221,1321002023100013,1103040030102440], + 211100120200012: [102102031320011,102223111000042,100041140201301,102140041342420,101000410321210,102140021410400,101013111000000,103011100120201,100000120202410,102300004110122], + 1442012230111130: [102110300311400,102101200234301,102302241004232,114100222340001,100423004100310,103210001410203,112014002003102,103020341402213,102021100240220,100021404302040], + 1133310214404000: [114040102210432,100031120101224,100034004211240,112040200233002,102113111343110,103234100101221,114002220010031,100010111040104,103103311424020,101030010320024], + 1104210302033040: [110112320021204,100034114100102,110330002104200,114000000030300,114101012201420,102112100210100,110011111104432,102000221034000,102041204000000,103310314020230], + 101000000212120: [102040431121110,100400002201113,114111100021420,112024212301420,102212000200124,100300310140241,100240134323001,102042000222002,102001011100100,114402104142102], + 240022213020113: [100200101000000,103110431441100,102101324130010,100011200121231,111201102224324,100102004100201,114040020021023,111230114102201,114201102342110,101400300300111], + 110033123001102: [114132202312102,100021110200330,103214104034020,100400000013010,110222201200000,110302400012002,100103004000123,101230234011000,110404010003212,111020014110103], + 1023023400200011: [102013024000211,114021004011100,102140140310001,100402022200102,111010302203001,102110111023103,100102434300310,100413300430300,114100102341011,114024200040223], + 1002001000031010: [111220002220100,100000241020022,101133410300302,132200010004401,100030044202001,110114410003233,140200430112430,112144312011433,110012030002010,110000040024442], + 101004022130342: [112014212301401,112001400220201,102112311101420,111040102231022,102200220232004,102200002000103,111034214120001,110000012201110,111203202222013,103100401240301], + 1001004301240203: [102023000220003,102332320243001,101004204212040,102202014030001,100444021001102,110201400000100,112013400220104,101022424011430,112321041130330,102113100201211], + 1001041022401440: [103140114002241,102000301100100,102024011413201,101300414221100,102331201001140,102101001342004,102200230211200,114001042203020,112220022044223,102104411412302], + 1120034100432201: [100412004102200,100224004100041,112110302300103,101000140200002,102200404003330,103103311210320,112410004041120,110140001201040,103210000131020,100400040022210], + 103224420030002: [101000221034203,102103004021421,114130002312044,114200014001411,110010042001410,100222044342300,400000220124000,421200120000010], + 1130012401013113: [100033114200011,102201130200131,112002024004122,100410040030230,112120110200240,111201002200020,100012020420232,100000101222004,100100011204031,103010021223130], + 130301200121102: [110032022002020,100400110020244,101042001021012,101100104002023,100124021201021,100400000010020,100411201002420,112213021100032,110002004413040,101030404003400], + 1032010030042331: [102012021321102,102141000230042,102402201110020,114044020020230,102000230224024,102321001000211,100010001040020,102103120210312,110200440000121,112400204040200], + 1144220213313100: [101020000300112,100002020410020,101000001111200,111120214102000,102113200210140,103130020213032,100040041020102,102323204113210,102403031110014,114000012303410], + 1434334000034241: [100002004303100,110130010102101,100212034221414,102000041101100,100042004301301,100012021031014,100000201032010,114010204101202,100404000020000,100010210410420], + 122440000320104: [112012012002100,102401024020221,111231012242301,114444004140210,100000120120001,114210224102122,102100112004142,102130004020041,112223242033100,110031214200342], + 1100300320130210: [100110214103200,112020112300102,114010000021104,100103121010020,103202300102400,100000001021001,102202044110341,103322000144000,114030424122003,112013300230202], + 1000000212201230: [111112000011222,102403001342000,101003301020022,100400020033040,100102431021300,110200212041001,112044204000441,111210224410302,104110100014103,112310402020014], + 100000404140203: [100023421041402,101144134001102,103002144042123,110012220002021,102304204110040,100210020410010,101000414002041,114034422302101,110421104242000,110220302043002], + 121212230444021: [102403004042342,111122004101222,114020040013100,114000222213021,100000020401302,111001100020413,111301204111233], + 112200123010400: [112124004022322,111300210014020,102103201320411,100100031043410,101033214211000,114001100024243,111000142201220,110141112044000,100034244303010,102003104000032], + 102001124020313: [110110200001000,100140211000041,102302004110231,102203004032420,102001204011033,101000114000032,110330042104010], + 100021010030303: [111111000014001,100014041042003,101433010300204,102114321401000,103113204001423,100002414201103,102302010212201,100122234300420,100400320013200,102021424001210], + 114042414400102: [100002020100002,102011014001111,102110410200214,103222024031400,100230041210111,200023002000100,103233140101001,102120011022221,102100300201031,112100120200212], + 1202420101404142: [110340014422102,102140004000100,100231004220242,130020100202200,101202010301321,103000000120240,100021210200200,102304024110004,100400102040013,120020430310100], + 1012011001000104: [101011004212201,110032022002020,100214230430124,103031234000122,100400110020244,101042001021012,103230011412301,101100104002023,100400000010020,100124021201021], + 102040001310021: [100032041021210,110001041213031,102300324010203,101110044200100,110414300030001,100030020011022,102040011121100,111202012222402,102000221442214,102040041320010], + 130411200111124: [110400000002213,101101230331040], + 1032100440000312: [102002130222022,114010332302001,102020220201140,110021021120041,110044410433321,112110022014320,114123100221401,100203310014042,112000221110010,101410300301303], + 1111210014110112: [102224101113104,100312331004000,103301244010210,100101031041022,100142431013000,101000031001011,100000240003101,114202144102100,102102401412242,102311110222320], + 130100202002204: [102200211120103,102101204002343,114132040223044,100200411000410,100404202200223,111202000003000,110232400010300,100131201202420,100220111000200,103100110110403], + 1040201443220342: [101220040300414,102121211343322,101003140301001,102410001111322,403111002011011,113210210400400,1140104002020100,110102000002203,110011022100114,1010000000034010], + 1020411101320021: [102102000213403,100140000410014,101041344000400,100020420123031,102412020234414,102202424111200,101002424214013,100012101022110,100034110410003,100400222200110], + 1144220000000000: [114132242201400,100033000122213,102140011140002,110110402012311,100041200201020,101422000302424,102204024011121,101101430332010,102401240201330,100300010420000], + 221002000010021: [110301011320314,111004014402201,100132024030302,121310400440314,120100331332002,100001000001210,111002204403002,132303424001013,123320003100311,111002002142200], + 1000310012201211: [101420104040010,101201201022032,111301210041010,114340002303220,100021204100214,103144224004012,111344320041124,101120011040200,110042004410444,102043040200002], + 1030042024010100: [100300110110121,102002322010030,100321101000003,102121041101300], + 112241022420200: [102132400232131,100114234102203,114001232300102,102323324112410,114400112311040,100422140030210,103000041402003,102000141133020,100000104102100,114212344000432], + 100322220141000: [110202012100020,110013202003320,101031241000010,102120231343224,111342020011220,110030332100203,100314114322101,114404232310120,103100034001310,114002202210331], + 140000220120124: [100000131032010,102300011004200,101010001030220,102100404023424,100012200101131,110032302102400,100140204233112,101042141032030,112414042011121,111020134112040], + 121200141102401: [112010002002030,100010401234002,100002334202400,100023004304344,102102010214104,100210021003100,101100104022212,102112004000230,112000011110231,101022000320113], + 322000014100120: [100002101021120,102102012003220,114110004121301,100104100422041,100001044241012,102030420223110,112002220220002,100200011000020,103120321442020,101444321101021], + 200230204201114: [103130234002321,103302040111403,100322100143040,102020001440401,100030240102022,102303320221102,102011221440020,102300001001300,103311034030000,100022401001413], + 1210140042010010: [112142301101040,101100000330120,101214440300301,101121100332142,100000400000241,111102214104403,100132004231230,102011004013000,111200122222334,102301024113440], + 1100130021002201: [122001010302041,102223044011234,1004130302142412,112021122222211,1301222204300302,1300100202010022], + 1021112020424001: [112303341100100,100043020123004,100110001000000,100000011120003,110300440000022,112020001110030,103421114002100,100200200430302,112033004000010,103134410122013], + 102303000232301: [100104302001300,1301223001003430,1302120110232200,100021204230002,1401214001003110,1023121121030343], + 1033201020042121: [101000004210020,102210314111120,100032300010000,114140404123402,102130031410200,100010300414000,114310134003100,114132302200001,114011014014042,100013004300240], + 1120100203000132: [100021000104004,100002200022012,111140204103210,140004010302423,114200320003120,100200113201000,141220400002200,100044231103400,100411033204412,110000001210210], + 133021042110020: [103000004002012,100002011042020,102110030200120,100301421002002,100202140000111,114001032300011,100240101000030,101003104212220,102302211002004,114030310012122], + 1120231232100210: [114030400020232,110000011220401,102112340210300,103001024000200,110001031300042,114100214000010,100000104201200,103000304010211,102110044002000,112104142300201], + 1203000001120304: [100232121210011,112022200234200,110043132100300,102220120203200,100002004201122,110132031134031,1220302241034202,100240200430040,114110342312140,1202111000310100], + 112040400320300: [102120221022200,100032011000241,102311011000014,114000030020101,112044414003133,101010300300110,112031121113040], + 122002002221023: [102300000211330,100340111000000,101211411020304,102314311100010,112432002023000,100122401023041,100200101000101,100400142200202,101311420343002,100201004220340], + 1001020210310120: [100000210100030,112210322040121,100402042200000,110001440041003,101402010301000,100000220111021,101000430320220,100401022201110,101100001110030,102210011101110], + 101021001312213: [102000402041014,102041410242244,102101220214011,100022010411004,114000424102300,102323201000412,102212434110001,114240044000100,102141020210132,112102314020000], + 220000000210202: [100301300121100,110042400130000,100021300101201,104101201240100,110000011012202,101001040302400,101244324043222,112102232300222,102000020241101,112311000204002], + 1000001024120010: [110200002031302,102040021121030,100000204130001,100412441010422,101010200312020,101040204210210,100000201034001,110000324412304,110000201230100,112020024000010], + 1022230100012100: [110013202003320,101031241000010,102120231343224,110030332100203,100314114322101,114404232310120,103100034001310,114002202210331,100031301020100,110111032140220], + 130100320202304: [100322014312444,102022024010214,101030004002122,100000424310110,113030342402110,101000331020102,110340342021001,111042010024001,111223010011043,113000200130000], + 102220224200222: [111001440020003,102001000212142,110200020010003,114121000002140,100002214100100,102120104003011,102120402000014,102000200210032,100041000100422,114020002303212], + 101120241111204: [102112200201012,102321104111003,111111004400103,112100022300110,100200410434002,110002022130324,102004221132241,100010000002102,100221124121143,100414300433033], + 1141030001400100: [114410002324204,403111002011011,1140104002020100,104402130010100,103100001242220,404200120320000,101201220402420,1040212001001234,1323104441242212,1001120000022000], + 100200114000013: [111100414100001,101004424001020,100120134234441,200010322231000,100203411001100,112132020203121,100000004211010,100120030402000,112123134024011,101010000313133], + 1011402012100420: [102142221342202,102001200221011,102420000202033,101000004010012,103024000103302,100012020410400,111111102240001,101301014220002,100000421024110,100104000101010], + 1110210222231122: [100200201002303,100043104240004,110422102121011,102042204010212,100023001030202,111000200040314,101014404011012,101014001001410,112000000221100,112030010234104], + 102231442403400: [100231401213132,114210104113314,114021232300112,103001000120444,101144024000232,101302121004422,100000010011430,100110000000000,100114420000140,102320021100120], + 120102020232100: [100024000110221,114130014001202,110010220103020,111004100022110,111001344400222,101021204010011,100404410022320,103012101410102,111000000000411,102131304003000], + 1004221011034003: [110011111104432,102143421000420,100300000441223,100000001024104,100104041000002,103102000123210,100104421021212,101012011111122,101120011140202,103100114000402], + 124131130120010: [110300120403013,110131002010202,101010010320020,102410124022400,102300424112201,101020004001002,100030031220030,100010100420004,100120300002212,100112211224031], + 1100222000410322: [100440031001120,102020200223310,103220011420242,100031201030331,102032012000101,101001400301113,112102102302000,100002120200101,102112011401424,111242110002213], + 1424112110000203: [110310001202220,102300321004202,103003441432012,101340141003001,101210100300100,101014424010103,102311410222022,100404000033120,112000112001400,100004110012001], + 130013214040300: [110040112132130,102221041100201,100204004121023,110111111010000,100413304100413,112134000201310,101002401110142,112230122030224,100110130000123,100200201213011], + 102123130022002: [101222101202341,110301442021010,100010024302100,100000011020412,112041000220020,102022400210202,102003034011323,111300000001323,110000002001040,110101000121214], + 1022303220040011: [100002100100210,102420424042020,100010001032223,103020031403100,102200401111200,102000430221040,114003104031111,100100000422320,100102020411200,102100012002000], + 1040240023122001: [102400100230000,102114022004023,101022121001000,100213310112333,102302020212101,102300104110002,100104201020032,112402000200342,114303340000001,100030004104210], + 1000000344001020: [103114001441122,100422004320024,114211110023303,111000302230100,102300011002030,100120220000101,103001101422012,4000113102314022,1400100000042343,113234032301042], + 103424220312220: [110112110030020,102331414110004,112000322311331,102003041130020,104100122102020,103001101240031,114211140213100,110201030002222,102212010202013,101102001100033], + 1103010110400302: [114124400000022,1104100000042000,1302001134003203,244000303210100,103100240003304,110000011101202,1310001001103311], + 140404030301404: [110111041011032,110243310101220,102221230200001,114100212200003,100020010022143,100101141010322,102100311400022,114003102303200,100000044310330,1311120031020142], + 121400400000310: [100020300200110,102342110212020,100042000200211,100024024200032,221123404200214,100021024100301,1101210010010223,102042000211301,1300004102024404,100000241033100], + 1142122203300140: [101042410301221,110432300102000,100102024100020,100011004102400,102304000210204,110040344210011,100003320401100,100020120101000,100003200020112,112143144020012], + 1013003111000104: [103300034021000,103311011404143,101011010320431,103041414001042,102441324022342,101041301000020,103220000104122,100220121003120,103220114040342,102040124010141], + 1002031042114021: [101012400304201,100031044300340,103212014020132,102102030214401,102021420233130,103220300101010,100102104301413,111130410020021,101022000302211,101232020300432], + 1043110110000102: [102214011111041,101020341034234,100002401040201,102113101342000,100212304243333,102302424110100,110002010042440,102022401412124,100121210402002,102212004030221], + 1001331032004111: [110001422030011,102144314002302,100220024324023,114200112340002,102343014022001,100211000430431,102142004001013,101213240301002,100140200410200,100020020120200], + 100000402043242: [102211230244321,112121214040022,100010101030000,100004004100120,112002100233204,102200121300400,101030224004130,112400024011003,100000004214021,102012141440022], + 1430140040400140: [111030212113431,102001111011201,110044320441241,102233034000002,110311110410340,112101202012010,102112314002011,110000121222112,103020040104002,102004004000010], + 1101003002401013: [102002120203400,100002020120200,102141004001412,102143000210010,102120221410141,103241001400040,102330124110411,102303342001023,100000024100200,101300124233021], + 1134041311041020: [101010001003010,110203112030000,110010034202123,101001334211011,100100310403103,112200010410210,110442004241010,101400304022340,111230112220110,112130400202001], + 1024004010201221: [112401024044240,102001000200221,100021010004200,103213004042404,114203400000000,102002214003000,100102104300111,112222420202010,114014124030001,101303104233204], + 1010021300000202: [110241024242442,110444010032242,110300112023012,110224200113042,101000020301410,114000102210200,101041001032310,103100100100104,102121414000042,110024030001401], + 1022200021121321: [102113300230021,100010044310002,130000420243230,100232104120201,102212234021233,100100341202102], + 134103120400201: [102302440220001,100104400403240,100020111221020,110010122102321,110002322101200,102220124000003,101020201003002,100230300001042,100311334020020,112400022020023], + 103320410200011: [100011004340114,114300204032002,102101101140040,102000021444112,100003010413400,103334120114003,102102030210111,101201041010123,102140341343300,100130204300200], + 101000000034003: [110130314400100,100032431030100,102022004010240,102023211411003,102340200224222,114002014033200,100004301021110,101010124001000,102111244000012,100400000034231], + 1010041121304231: [102040431121110,114111100021420,112024212301420,102212000200124,100300310140241,100240134323001,102111024000402,103220011411101,102042000222002,102001011100100], + 211402012042204: [102240120244002,402010003200010,101003204000004,102204424033103,1014410101001020,112010412020141,1002001101203410,110020102120001,402000143220001,1022200220012110], + 1024402042014412: [110441140102024,101004120224442,100413311002132,110210301200101,110400241240242,102210101121104,110023102103200,102400140230123,102112300222001,102000024010002], + 104033122104203: [102001204003131,102101041340032,103010110120332,100012020204300,100001104301010,102320110243020,101002020304011,102432314021013,114001400022003,104010000000320], + 1000000210013001: [101301014221122,114220040000201,102102204022310,111040032200021,103030040121410,114040210022000,100404400013222,112010420241002,112201010203210,100000214310412], + 1422024020131310: [103000140141214,102110000210300,102422021113012,104220041321240,101021321034010,103422421110341,110001120421122,101440000330201,100112044302010,100000114300210], + 200101430023042: [101321001000010,102042031102112,102410111110002,114102302311211,114034400040402,112122334022424,102122000212204,100422021002002,100010100102032,112010344023013], + 121000110044130: [103102010212440,100021120412010,102002344013100,111200302214000], + 301200000024111: [114020000030002,102430401401200,100201211003004,102014002000401,103103241421322,114121012340044,102000400240203,102104304023201,103310300140324,100002224244002], + 1002044041220102: [100023101042010,102112310210202,102330010243440,114042044100403,114221224002403,100013310123100,100022410101442,103202014031021,110212424242341,100101014300100], + 120100240203013: [110040022130003,100030430422242,101120014204000,100100014230110,111002132202012,110201004241002,111004012200303,101000131142230,114200010213030,112001204023241], + 1020000000320004: [101032111230411,103010110120020,110100032122000,101020210301131,110304002000013,110200001314040], + 1003212301102334: [100042304102210,112202000411103,103202000110102,100013030100002,102020440220202,100042000000000,102334021001211,112000021122010,100021111043012,114003022300020], + 143014043212013: [100012001023022,101104414002010,102112012004120,111112242211204,110422020000111,100000041201200,102003340204010,110003004420010,100030201031300,114110410231111], + 100014200010414: [100024000110221,100110020031042,101301014221122,110422102110221,102102204022310,114130014001202,110010220103020,111004100022110,101002201140040,114040210022000], + 104220102141320: [100011231042030,100020034100101,110004424200024,102111144001232,103312300110101,101403004022114,102000441132020,102024044012212,102222244040141,111001012203002], + 202402000201323: [110403244220202,102001210223212,103113014002100,103030034003020,101144010014213,110120400402324,100402340010310,114022234031002,112010440244302,112120424043000], + 1101110101002030: [110301222101110,102230040200031,110122001010214,102023301102400,100030414300112,114043140010022,104120110010402,111010214402000,110303104423010,103140104002400], + 1100110032402300: [100024000110221,101301014221122,102102204022310,114130014001202,110010220103020,111004100022110,114040210022000,111001344400222,101021204010011,100141021004020], + 1020010000100113: [100122004300410,114443330001442,102000224000011,103001104010010,101212040303123,100111201014214,102024001010002,100021021000101,102030200240232,100011124202310], + 1000100110200003: [110111111010000,114120014004003,110000031031240,100002244111003,110131311200401,110441222110003,110000120020421,112010204002340,100014200402310,114110440000200], + 220034132222212: [102334004110232,110311331003000,101020240300003,112300032000100,112021334001000,101000100322140,100144430411240,111000024401300,114010010002314,102321040213311], + 143132242124002: [103114204002100,114230004110101,102142002000030,114000024101202,100100114302030,100100014302013,102020121130000,111310000002001,101022000322402,100002114104410], + 1100020000202210: [100012330001024,100020134300020,103102000100210,111224340011202,101140004203010,101220004013020,101002004010200,100001020120320,102120011022221,102100300201031], + 1140022243233000: [110013202003320,101031241000010,102120231343224,110030332100203,114404232310120,103100034001310,114002202210331,100031301020100,110111032140220,100020010200022], + 1003410102003110: [101141314000221,110033101314000,102203111103200,111000000001211,112304041103131,101041014010212,100400310013004,102220232001303,110020102202100,110301120042202], + 1121012101041301: [100011201020234,101221000302204,101040010311213,114100200002111,101000034210022,101322201001022,112420042020110,102110120210211,101022310300133,102014400223314], + 214201002230210: [101001011114020,100030044100103,102012040223003,100002110014312,114042004100020,110320042021132,110012312014200,103000000110000,112000202301020,100200110002212], + 1030020004011140: [100104010021241,114002014033200,100004301021110,101010124001000,100210224243223,114020214022000,100124011040300,102103020232040,114114414122002,114102102344110], + 1402020020440003: [114010034012014,103200031411100,100010004300024,100000324340102,114443200000122,114000102300102,114444124143021,102101000233100,103030024020041,112100334020030], + 110020003122121: [102101211411000,110032022002020,112032040234431,101004310324302,100102224033421,100120040400011,100400110020244,100124021201021,114011120010030,100200044121414], + 1003312101421000: [110011111104432,101003201002421,102034004000133,100104041000002,100102240002022,102112411140024,102113000210043,101120011140202,100222200010312,102114101120004], + 223242040210040: [111432404442442,114421102322111,110241022112013,102110010230101,102111401120001,102401224021023,111002004401000,100000024102020,110002232202002,103014044010100], + 102000320311023: [110414402020021,102142030224211,102011011131130,101000034000220,114312012300300,112402032010131,114102140221100,103210120100143,102112411342231,101010024213100], + 1144013000030010: [102000020223013,114040102301100,101022020340004,100020241043022,114413232320000,100100001040134,103002034011114,114441124140100,114440200000000,100002004130101], + 220444412203411: [111142010020301,100000144104100,101014014000004,102110021341000,112440220203204,100100104102141,101033141030001,100001144100001,102111210230204,101003400322022], + 100000033110323: [100003011041040,103200141404212,114014010043112,110104140001020,114001112300222,100203141001002,111000312112404,100400020022110,114122440000024,103000020103121], + 1424010020100024: [104130242103012,110100221223104,101022024010004,102000101132400,102412101112121,112023140212112,102404200230330,102110244000130,114000312301300,100102304302000], + 1020221120031000: [110120144200000,114022412330004,101200221022044,101041030320401,110241112020204,100002004104004,103130021444021,102100104002224,102100224000210,102103321411004], + 123314020421000: [104210402020230,102020230211204,110403022010001,102331004110020,112400204040200,111200124130121,102444210232043,100002110402000,112111240220303,110413002221000], + 1101010402212203: [100014100100001,102100004130301,110100001200320,111120004100414,101034024000101,101243024011000,102200230202120,103340410140122,100010021221221,111012202111021], + 1040320000224321: [112314301103022,102000222003200,110112211000311,103100001440000,112010402302400,112040400213330,100100404232002,111000122144002,103010141244132,101032301032001], + 1004102104014200: [102301004110004,110402420402001,110021021210300,110404000000012,102000101120123,110020310022021,110301322104142,100020311220412,101121021020012,101004301001120], + 1402002011201113: [110011411102000,100022001022231,103100201440230,102314032000332,100002001002004,112002100214012,112112424020223,100002134302300,111120000020100,112020020231002], + 102010201033224: [102022004012201,100000024210130,102034221103124,100034024104211,100014030200221,100020134212021,101201004203204,112001120220130,102010101320314,102102230203330], + 114201403032204: [101000004000241,100120000410020,102311000240202], + 132001440041043: [101004120224442,100413311002132,100320421001431,101233021020010,110210301200101,111131102210013,110400241240242,101001024210000,102210101121104,102000324010303], + 1013001222410000: [111214100000104,100430221011100,110422010000200,103112021442033,110044014410012,100112434101120,110030231214100,111121012243322,110100144404220,110004001040434], + 1020121032342040: [101000041031301,111221212223401,103214400131240], + 1112003201020140: [100042301001230,110002240134040,100020200023001,100040014310020,114000014100101,110031324200020,112202304002043,101110310331140,101003311030410,101000201000000], + 1004412014011021: [100004001021111,101021004214202,103022021431010,100003000104203,102101220214011,102114320203000,114001112300001,101003104212220,102120231343021,102311110240101], + 1430110020341110: [100031224102002,103000021431010,100030100104000,114032002301221,103321004033302,111332432200404,110013234211140,102100221341020,114020004100033,102220020200000], + 120032410221422: [102044314000340,100000210100004,132200430040010,122333101001221,131001104024402,103203211411200,101003210300230,103004004012040,110320010100000,110003000143033], + 1002000121311220: [101220300304010,114203412342202,100010031030401,100101001010214,101012014000204,102334004110210,110203100100102,112032400230000,114411100002000,101004004000022], + 1114000414100400: [102142221342202,102001200221011,103043404000202,102420000202033,100020101020404,100002411021201,101000004010012,102110010210330,103024000103302,100012020410400], + 1001130132121100: [101301014221122,114110200212210,114220040000201,102102204022310,114040210022000,100404400013222,110012130410040,100104101200201,111040100020010,112201010203210], + 1410122202341013: [114010200040441,102011001134111,100000344100100,102302011002003,100012441030002,101022114003000,114024210021201,100013001041311,102323014020022,100120001021200], + 1433002000024010: [112411140200242,111201202221200,111123002210402,100011004203023,103001241432010,102022020220023,101010020304020,100010001043003,112142020420000,100140001042400], + 124102122003001: [100002121043000,102200031002000,112201011040200,112040101110000,114143223021220,101102312120003,1203020102314000,101043444211200,101210000300324,1301400104300023], + 110010233130000: [114003212210013,110302012103114,103023101400002,110010120440200,110024140022040,100002100100320,110100034200300,100401201010220,103200024021204,102100204000234], + 210302001041220: [100101024303332,100013201020230,112300101101010,114301302323032,114200304000002,1300040101002020,123310121130130,143442111023013,402014100021201,1022003020311200], + 1200300210101130: [112202012024101,114000240030002,114002322300200,100043101221020,103244034020020,100142401000440,110021202200101,102422010203030,102202101300002,103230031200102], + 1100314214013301: [100024000110221,100110020031042,110422102110221,102102204022310,114130014001202,110010220103020,111004100022110,101002201140040,100211000412142,114040210022000], + 343202010004200: [103222114034232,103221204032410,100004004102410,111121004103434,102112041020001,102202014042012,100010001032200,100221110101420,102441030231300,103032000144301], + 1002010010013340: [103020031403100,114000044020204,102302331003300,102320000221020,110142020400012,103131420221204,102120141343312,114321114032200,100142011022211,114230344103210], + 100101010121421: [100110020031042,101301014221122,110422102110221,114220040000201,102102204022310,111040032200021,103030040121410,114040210022000,100404400013222,102320234030000], + 211000110104320: [110301222101110,102023301102400,100030414300112,114043140010022,104120110010402,111010214402000,110303104423010,101221420303120,102000324040402,100100401040001], + 120302301110101: [110300120403013,110131002010202,101010010320020,101120101100112,102410124022400,102300424112201,101020004001002,100030031220030,100010100420004,100120300002212], + 201402003042204: [114212012310002,110001420000233,110000230010221,110202110113000,102200301110320,110001040000000,100324114310222,100422020030044,110002242100100,101220100303222], + 230244020001220: [112020042344001,111101122102222,100241000430420,103000114001000,100003344214000,100221201210110,102322420210320,114124040000002,100112001021112,102110104000020], + 1020004121021033: [100430014323000,112100021100243,100020224101220,100212101003134,103030014000020,100020024100324,101230011020020,114010214032000,114111240001012,102012201414304], + 240021120110320: [102020112000020,100002204310230,102430424022023,112110012010100,101040001021020,111010120040120,102030004000432,110021002014130,114010130032101,103031000100122], + 120044210000302: [102101021412120,110024020421011,100040224102124,102100011000033,100011214102010,102112241342203,100002004200212,110010332201012,101010404010000,101000411001330], + 101420000132212: [103034010121101,102302200210010,102340120222440,114223204100010,111041202200140,111300400002313,111101040014040,100023014313010,114021040010311,114140004123122], + 213000021301220: [102011114002011,114101042202201,102144201402040,100014201021012,110000214214420,114021212301131,112010112000311,110030441223002,110440002111230,103002044010020], + 1022001442221000: [114010200011100,102312300220000,101142014202110,102310110213220,100012001042030,102000404000400,100013040404011,102004004004200,101002134011001,100300300421030], + 1132130244110420: [101221121202421,111042022141200,102300220241031,101441101010020,100442220030040,100100241020020,100002004342004,102312200240012,103010330100320,110341420400423], + 1044123221100003: [101004010304203,121200013012000,102122210230200,111001410004002,103110411212041,110023000042010,110244400212004,114410104141020,101002021110410,101010010323022], + 1000222200012004: [100001024201214,103433121201311,130014300140410,103404001214121,110113211301114,103000044041243,102300002103012,103204104020400,103202341200300,111400202101243], + 1020201000000102: [103402021210242,101143011131002,100001441032301], + 1422401100001213: [103300021400021,114212222334101,102303214113000,100101310400220,111223010011043], + 113020033000101: [100110020031042,101301014221122,110422102110221,114220040000201,102102204022310,111004100022110,103030040121410,114040210022000,100404400013222,112010420241002], + 300143320002020: [110013030403023,103010204010010,112003002030002,110401231001202,101031211140304,114230110212040,100111110400003,100000034301140,102111011142022,114132142312022], + 100012211024240: [101023211102101,101012104001020,102022001101234,101210120302002,102000304001202,100010300121000,101233100300011,100001314100400,112101201102130,101004040320002], + 1100331204103000: [114420112320212,1020343020202224,1010122010001200,1303010022004241,101012041142400,130001344030034,400000133010010,203322214210110,403240003100140], + 1002220100012020: [100032041021210,110004301222000,102001301120112,102040041320010,103203401400132,103142111441040,114142044120310,110220410000040,101030004010034,102201411100212], + 1100104411021114: [102202201120000,114301022320021,103030404010000,112100102012303,111302202204022,112003402002003,102012044013241,103234004024024,110012010122100,100101004232101], + 1040012233000202: [110311011200000,102122100201100,100120100400303,110202202032022,101020330314241,110242101314034,100101020400000,113112010233312,112004200210302,100023041230312], + 1020434431040110: [112000130230100,114212002340000,102203204044020,110412004242114,102120012000012,111412104420221,110002220023400,113201230210100,101012134000100,101000304001213], + 1101001244010020: [100041000411231,100013014102414,101004204210100,102011001320032,102140040210040,100034134300203,114202000000000,114312012320120,102010031444104,103313300113232], + 140100120021021: [100040010001010,112003031110244,102014004002102,103102214000020,100000004211200,102022401131220,102301234110020,114011410020033,114312104030000,102332401000010], + 1240012103022112: [110021000410432,101010010320112,112000021122010,100021111043012,110124041140000,103300021402104,100010044101002,100001000100403,102344011000202,100020124100010], + 1400440000000120: [103122020213112,100104010021241,114101100211240,103012011434022,114102102344110,114010002300003,100112110020301,100000004102124,100022301000112,114121030220301], + 1422011000000201: [1034004021300110,102001034010113,1100440001000000,1020401400011242,1042410022214002,114222442341000,1042210303140101,101313330340001,110044101320101,101040201121012], + 1000034310000311: [102141040210012,100002230102232,114110012310040,402023203200200,422202004012314,1004020103113032,111000000001024,110230020421020,400020112402100,101010124002440], + 133143012100100: [114000242200010,102011201412140,114000300014032,100041121022141,103012204000012,102100100220230,110400032220312,102000211410100,103334010111101,102010200223020], + 1142430110043132: [112001232000034,111203102223243,114112434000040,114311400000224,100040101001132,102113232001100,101110044000400,102102021002000,100101021021101,112001010242211], + 1101310100024300: [103021024013303,102001034010113,1300102201211020,1300022002310414,101313330340001,1112301032024000], + 110032413122402: [114001000020102,101020040300010,100213001000212,100002004212420,102121014002022,100141404233000,114131002342130,110002022003101,101020001030204,100403122201202], + 122114020014230: [112413224040101,100220100110400,101200031020230,102403004042342,101024001034211,111122004101222,114001012300002,102121100232012,114000222213021,114102330210021], + 122410322020002: [101011004212201,101010304000003,110032022002020,100214230430124,103031234000122,102044021101411,101100104002023,101042001021012,103230011412301,100400000010020], + 200012131210203: [100201104211021,100020104100331,100432034100300,114021140030212,110420241240103,100030200001122,100004341223313,101200101022022,112011011120400,112211200411024], + 130001321113022: [101301014221122,114110200212210,102102204022310,100104101200201,100002204100101,100020300102123,100120430411222,110014314410140,100022014302423,102221101122111], + 1212102022410221: [100111211021233,112001022300000,100203210003004,101214000012021,110003001024303,101000044001103,113411101044400,110110011240242,113020002200000,101104010310340], + 1402400121202023: [114300304001000,110023401320200,102301224110000,110000312001020,102133211401043,102010214000003,100010114200031,103002010100104,100220310430010,102410110232000], + 113121200120004: [101022014222024,100032000101014,103030104000102,111311002224001,100032134101100,114201024112001,112010024023002,100000421024110,102130314134001,102011211102101], + 1401420201003400: [114132202312102,103214104034020,100400000013010,102142020212132,110222201200000,110302400012002,101401140300144,101230234011000,102202000202411,111020014110103], + 1141024241430004: [111301240010310,101300400310002,100000311221002,101120321040104,100303101000021,111001212232021,110002300420010,110021002003020,102202110230404,100240011003010], + 1420012001304124: [114010024033002,121000042140301,1300102201211020,101201001024132], + 1120003422140130: [114002104014300,102000311102212,102010004040000,112433112020200,112301312020123,102000201101332,102231041120104,100111304300020,114132420004104,114100110220013], + 1222140100122003: [111034014401112,111302202200213,100030241043214,101421001021031,101300400313000,101220040310221,102320030240003,202030010203100,111101422241002,114431310000020], + 1430041300203020: [110000411313130,110400000001201,110000010430211,110001212130303,100103301002044,101221311022241,110100231202400,110020102102000,100000201022030,100402021012201], + 110232022201000: [101001040340004,112022334022101,101011324004222,103210241422022,103240001403000,102202204040220,102121010212140,110020124200230,100004221041210,111103212211022], + 1112000320000024: [101032111230411,103010110120020,110100032122000,101020210301131,110304002000013,110200001314040], + 1032100004421232: [102340101000014,111203032220113,102140200212214,112241010203003,103010101412020,114020110001011,101031140301430,100303021003013,101133001110034,114004000021113], + 1004021000312004: [102042310203001,114010022302104,102002401444410,102300200220002,101141430330003,102121211343322,112111002010002,100020314100010,110000000040030,110130144202012], + 1040324200242131: [101032000323012,100002201031130,102003104011100,110444300101200,110011024414011,100011104344414,103300204014142,104133200011000,114203022320321,112234142031230], + 1002101401014100: [100032041021210,110004301222000,110414300030001,100030020011022,102040011121100,114310000001232,111202012222402,111322234130000,102040041320010,103203401400132], + 112013004010200: [100221414100030,101042234210011,100001124311011,110322002100130,110000032003020,110011404202441,100431344122010,114120434002420,101022000302412,111000102202120], + 134312030143303: [112003000224300,102043100242004,100430214302020,102012004014321,112410112024141,114100100000120,100000044230421,112041031110300,114121204120122,101000301142210], + 1400041101200320: [114423100001142,100040214100420,111304104130300,110221030000000,100402210010221,114000200023022,110200420000411,100012101214010,100022300042040,100300421202043], + 1044310140020021: [104100002100221,104310001300102,102000321102310,112000044002102,102134044134410,101202001022000,111300220000230,114110032343001,100110101040020,114012222301110], + 103001000111042: [110430000400002,102124231401212,103032201404142,102243044041110,100100104302010,100201210430001,114022042300011,114113000220431,102101041412000,110022411321002], + 1142200100121230: [102113020210002,102031001441000,102011021440030,102121124130314,112032400230000,114200002320110,100142110410122,111030002200011,100124024031000,110002020024020], + 1002100022012030: [110040022130003,100030430422242,101120014204000,100100014230110,110201004241002,101000131142230,112001204023241,100104044230000,114022024012213], + 200002000024220: [101011004212201,110032022002020,100214230430124,103031234000122,100400110020244,102044021101411,101042001021012,101100104002023,103230011412301,100400000010020], + 100002014220224: [100102000010243,112300042020334,103012200100120,110402000100440,100011110200210,102131020200344,101030414210000,102201004111020,100000211020431,100442024301200], + 134310010102002: [111210044131101,101242421020211,100000001224221,112301111130031,111204200002001,101242000300323,111141010000303,110210031200000,110100112141101,111230044134200], + 1430404024014400: [112000112000031,102022124012030,100143220410040,112024000213011,100103030001121,111000004400110], + 1111030010301130: [103100030100010,101400004022100,101421100301230,100003414100400,102013110201200,102300121004222,114221004002212,112000230220102,112010022302321,102000324011143], + 133220000022012: [101042010300204,100001021231414,111222034100421,102012304011012,103414304004120,103120104002021,112110102310101,102000101102200,101020034211130,111212224410011], + 1040030243120202: [102022200223242,112142000203203,100011210102401,112010102001413,114423224140221,101200004200201,101411400334310,102244110200013,114140014120332,102200111120010], + 131020030000000: [101011411020120,101000010201420,1320010021102402,201200032021040,100040011432042,401000020221031,1440003320032101,100201001100200,110021020011204,1041011113104304], + 1131042034110330: [110211010012201,102014000220330,100010110000100,103122210103032,102310114033120,101032134211200,112113001100100,100030001042002,112024100240013,114204302322004], + 1100031110040021: [100310120141002,100004001021111,103022021431010,100003000104203,102041410242244,102101220214011,114000424102300,102323201000412,102120231343021,102212434110001], + 222004301010330: [100024000110221,114130014001202,110010220103020,111004100022110,111001344400222,101021204010011,100404410022320,103012101410102,111000000000411,102131304003000], + 130202311403002: [114034220041220,102102031403230,100024004210111,102002100222202,103343010113030,114040202214201,103200234030122,101001100320224,102140020210040,114121114121401], + 132140024010423: [100011011020440,101011001103200,101002121000111,114023314013200,102040104000040,114022120040112,100000201024213,114003422304142,101400031014311,102110230200201], + 1004302302144101: [101020024001041,100200201000001,102100000210002,112224232044014,112002100240200,103032004012111,100001404100110,110131022014120,101213110310042,112000002000110], + 1402400004023031: [102202204040010,114200402332011,103333040110114,101022200343023,102000000221222,102011014001111,102101001342004,102103001414002,102022011101012,103002014010030], + 213034032030421: [102020314012030,112014010202200,100000000410010,103201000102140,114220100000331,103231001400100,100101024101100,103012131430321,110414002024222,112321001130024], + 101201440241104: [100024000110221,101000130320340,112401314040311,100110020031042,110422102110221,100220124221000,114130014001202,111004100022110,101002201140040,103030040121410], + 120202142213301: [1122204031101014,1001412211040002,140011220320300,103144011212002,1304032042210300,1100220200041014,124211403120110,214301004122000,1003124230010302,1003033202212100], + 1040020010132001: [114043010040031,100000101232023,100110044032141,100000021030000,110030102131421,101000204001222,100243331003301,100023200423040,103231010103110,100002404204111], + 1022301000020002: [114000024100022,101020030332430,101022004214304,101001231032003,101001020322010,114112244122013,103310220113140,102443421400110,100043041020120,114200202330330], + 200000200130000: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 124300020100404: [1300422220310121,100422321032021,120032010212320,411001103222300,411311131413022,1220101103414143,320440200013001,410000244003240], + 212210122040221: [114021222212030,100020044100000,112440102010141,102024011104230,101003134001003,112000032314010,102131011120000,100220010412420,112012122000100,110000121024413], + 101211020120212: [102111024000402,114321002320001,103220011411101,102001011100100,114402104142102,102311120222404,114020404020132,101220111023331,114220014111304,114400202310013], + 144400423212012: [114231202331202,100003021234044,111102032220111,111300042200340,101010041032322,114020042300022,100021421020002,102400004040100,111120204100203,100122101040022], + 120002310030424: [111042000041011,112040232002301,100023124103021,102120411023000,102000000240101,102020040223423,102201110212212,101111201110101,100031030000000,102020214011010], + 1022001014201412: [101111104002440,112110020420002,1042102110020300,111403000002120,111001212200010,114131000001010,100032321230000,100400020022430,112201200203302,100400032200431], + 130044340234131: [100100300421022,101204121022310,100342220042002,101012121022204,114022002212232,100212220001141,110012102000311,112422000200003,102010004010020,114004104110000], + 102131002430004: [110100012120201,110020204200342,110002022002032,103303031402100,100004214301320,110302004430024,102023301101100,101000340000101,111203002221000,111143344100203], + 1043014200300422: [110000100422111,100021110200330,103302034020140,110201021201020,102100101320344,102331131001113,100021104301202,111121302103104,103314201402401,114221312332014], + 210002001114021: [100030220100110,100002114314022,102000100200100,102020400244030,103112100101020,114402102312001,110001102103432,112033300230131,110102002011031,110032402130011], + 111304114430331: [112142301101040,102340221000300,101000130320340,101121100332142,112401314040311,100110020031042,102011004013000,110422102110221,111200122222334,100220124221000], + 1122024011010110: [102424000230222,102102100210000,100002420121000,102001301320420,110202012033100,100004401020202,102201010202021,101210321000020,102002411102300,102200434122241], + 1402110011421000: [101000141031222,102000421131000,114404020003022,100421242201010,100012424200031,102043120222040,110200200001000,114023024101231,101410114043204,114241202320300], + 211022010223200: [110210114434301,114220024004132,100020100101101,102300310242221,114230012340300,112002030232410,101002214010010,111123224101232,112104020200001,102222001000203], + 1001011142003122: [110212022124220,100003100410042,100222034340301,101440044041401,111210012243010,102130124000000,102010421413322,102114020210302,110240301111040,102113131343200], + 1020403200202212: [100430020001120,103000004010400,100200021001113,100100301000012,111222004100001,102110010202221,100120001010201,103212111402314,101231400300040,100002204100020], + 100020000202203: [103044301431001,102101142002021,102010220220022,103211001412040,101004114210003,100403304320200,102213241100111,110200024432011,212240000101000,100022202042210], + 1100141402200232: [100043014203003,112332000411020,112230024010203,100000004244400,110024001211221,102012201441404,100131014234134,112000120241120,100030224300202,112202140201200], + 110320003031232: [100113220020101,114031000022030,110110200001000,102302004110231,102203004032420,103001000101304,100020110423022,101000114000032,110330042104010], + 221100101043122: [110020000114010,103202100102142,101020014000210,101002330300234,114012200021133,111000402224222,111230202241100,101013024014031,100242021003200,110100222000112], + 1044100431110022: [111122100010330,102302231004020,102110031342012,103001000141212,103211324003020,114014442200003,100103121044231,100101201041310,132012000000230,102320211001220], + 140022330311203: [100301300121100,110042400130000,103020124010320,100021300101201,111200020004203,104101201240100,110000011012202,101001040302400,101244324043222,112102232300222], + 1143120003240000: [114101024120020,102004011440212,103140320213200,100011204300012,100001021221000,114003134011032,100101234330123,110024000432310,102012101443110,102102104000102], + 112030000433004: [110100111221242,132344004001203,114303202300104,102100300233312,111021044400403,101241000303240,111330012201120,111021222200004,101000030312102,111001320002031], + 122300210010412: [100422000031421,110302040102004,101402114042420,102220021120430,111341300012200,100102000010243,112410034040040,111302304130401,100024334203210,103031410122401], + 302201120300411: [114031004020241,102232401114310,110010412000231,110120324200000,110401014240131,102000004002400,103120120120122,103042204000321,100122004233201,112102311102012], + 200110400100000: [104110021244203,100200004301323,110010030440201,110041002130210,110020004414024,102103022002001,102102224000012,110322100104010,102100102001032,100142431013000], + 131002012300012: [114042304100001,101211240301300,101012220324031,110410412110241,114203134112000,102000000221441,101023230330104,100130124030404,103014140101101,111131132101000], + 1040014002021103: [102301211002042,102343402000000,102004044011020,110423400000221,100121221000004,111402144422140,101400011102010,110220001100213,114120200220012,102213224030422], + 1000433000212130: [102040431121110,101221020040220,114111100021420,112024212301420,102212000200124,100300310140241,100240134323001,102042000222002,100030010102102,103312241402001], + 1124032330300131: [112203011103444,114000322300011,100002314302420,143310043400402,100120014234012,101104300333034,103202434024000,100302034100120,101023124012440,100023020000304], + 1021240141202021: [100043014203003,112230024010203,100000004244400,100131014234134,100030224300202,112202140201200,112001124000003,100204004122414,100003234202001,102311000240102], + 210031201011421: [110202012100020,101031241000010,102303010241010,102120231343224,111342020011220,100314114322101,114404232310120,102230130203001,103100034001310,102021401324232], + 200220002202000: [103200211420103,100202304341102,112203242043001,114110012310420,110104434402221,114323424033100,100030034340432,100402300022020,100004001021001,101020204002120], + 1021100200121000: [102330004110200,100000004134002,111202404440010,110100331001102,101020031001112,112422020201002,100100001202011,114104030222003,102320241000010,114220200211110], + 1100040012111022: [114213134000203,114300020001420,114133230000102,102400100202230,101021120323020,100102101000203,100001021030011,112410220202110,103141210104024,103200110102141], + 1002210140313013: [102020100211004,100300031003200,101023000340120,101020200302021,102021030221122,102241210201000,114040222301101,102140110210424,101201000300222,101002020342202], + 124101000140330: [100024000110221,114130014001202,110010220103020,111004100022110,114040210022000,111001344400222,101021204010011,100404410022320,103012101410102,111000000000411], + 1000311010001022: [110241024242442,110444010032242,112220001100200,114014130041210,100001041031013,110224200113042,101000020301410,114000102210200,101041001032310,103103210111220], + 111222444412200: [110300222104222,100002040410130,100440001000012,100403011002204,110202414214022,111002420031340,112432142020024,101103012130233,102320304030000,101112241010002], + 120022401312010: [114040100030400,102301011002321,101012011022300,100401401003240,114100002340040,110003301213002,103412224020402,112033311122000,100210001002210,102110120202141], + 240011012000022: [114400022321400,100011101222101,100030411042022,114304212302401,100000014201221,110200030001040,102312021101141,101010001022001,100020111222204,112022400231120], + 1003443010100003: [100140101044224,101120004023340,101000211032200,111010130002222,110200300000010,101210000300320,102120022000224,101310120314012,103114014004102,111213130001022], + 300030002203003: [114200212322001,100401210020002,110001440041003,100010111022102,100220300410430,101024201114010,102412220200003,110012222000144,100201214123301,114302122323101], + 1000202400203210: [110001332120300,110003000420200,110243234240200,110004014411012,114220040000201,112000120232022,102041220200010,100002320113100,112240200202201,110020321120011], + 110012304000042: [101220040300414,102121211343322,1320004203402400,101003140301001,102410001111322,400020203022020,113210210400400,110102000002203,1302200002412211,400100441040022], + 224200000220000: [103111001422000,101400004022100,100300041001121,101240004011021,101114000332010,112112211102024,114031212300211,102013110201200,102111022001024,103210431422030], + 110013020043243: [100114004100001,114102300004024,112102201102030,103222244003021,102420011111224,100020004300114,100340114211043,100033001220020,110232020002221,114233002340141], + 1412301200202400: [111304340002030,110102000401214,100100111044040,103140014002031,102024102020000,102224241110003,112003020220120,114113014000010,100043024210301,102014001130100], + 112341102400140: [112302112020021,112010032340022,114120304000212,100141410402200,114111202313213,101042041021001,100010031232443,101211414040000,100242024100000,100114020414244], + 100100340021203: [112142301101040,101000130320340,101214440300301,101121100332142,112401314040311,102011004013000,111200122222334,100220124221000,102301024113440,100033230420102], + 1403020230013200: [111240220002100,102010111102410,101000110322242,110100001014311,102404110230202,100010020101222,101222104010140,102120400200312,102001144004041,102304244110431], + 1011101011001300: [100001141221200,101023001024400,112020002311112,112000030210340,102201000203202,102111320321320,100302120421003,111200300010114,102020341100213,102010002000404], + 1001320200302310: [101111140300020,102140200212214,101031140301430,100303021003013,112141320423240,100220014223020,112300140200131,103204200110201,101012134000100,101100034201000], + 130310031021023: [110400112011100,100321004011041,110002342100014,110241024242442,110021312002040,111101042244210,110441010002400,110124002040002,114203104001000,114302200014241], + 120120021320220: [100041000411231,100013014102414,101004204210100,102011001320032,102140040210040,100034134300203,114312012320120,102442424021234,102010031444104,102341021101200], + 1000300034321112: [104100002100221,102000321102310,102134044134410,101202001022000,111300220000230,100133204300040,114110032343001,100110101040020,114012222301110,103120440104110], + 320113202410010: [103000001004002,103012000142231,102344210242220,110102021011203], + 100340003310300: [100301224310100,103002104012101,114021000012031,103220130211414,100012324202240,112101102012030,110003410100312,122000430101030,114000022300301,100311000141022], + 113231120202140: [110012031011302,111200104411001,102121200313040,111011104401124,111201004131300,100300021202320,102224202023120,110334102021144,110304202202001,110421000003000], + 1024222012010320: [114020000030002,114031000022030,100201211003004,102014002000401,103103241421322,110110200001000,114121012340044,102000400240203,102104304023201,103310300140324], + 1201111102102101: [100004001021111,101021004214202,100001010014420,100003000104203,102114320203000,101011001103200,114001112300001,102040104000040,102311110240101,114002002300302], + 102104300404420: [110441234224400,110310020040401,110202204430020,110310002221402,110030002130201,110242100010130,102103320232241,100200000000210,110200222111020,110220044210202], + 1141121340202000: [112202000411103,114003344011001,101040100302002,101203001010111,100310034310200,101000314000042,114003022300020,100031201030102,114201104114111,101041001003300], + 1000300210004143: [112100124023402,101020044011003,100002414210010,102010042000041,102242204040102,102042411104200,102321410240300,100021014100124,100130244302034,100122040012210], + 1001000204022133: [103002001240043,112023420232024,112002002003003,110002120000000,102340001102023,101202101000104,102100034001000,102302121101002,100400230021400,110001200421021], + 1122211200020042: [110414402020021,114020014110120,102142030224211,101000034000220,114312012300300,112402012020000,103322241400404,114102140221100,103210120100143,110000121300012], + 1010020022012232: [111010204402020,112010201112142,100030134100201,112012424004111,112000020240130,111201000003100,112000204000044,101004014210342,103210000102340,132424430000000], + 1102434010413110: [102340221000300,100402002201002,101011014002032,102104101122100,102423114022101,101131201110300,112002010221020,111012030020003,112000011111003,103210230131414], + 120102000220100: [100002100100210,102420424042020,100010001032223,102111024000402,114321002320001,103020031403100,102200401111200,102000430221040,114003104031111,100102020411200], + 110212320000212: [114402020004242,102242304042410,112032012004300,101001034002001,102000014004040,111020004400234,1010120030012200,101024411001024,1042012320010021,221104221024023], + 1102110000340210: [110230102122422,102300400220221,100013024201330,112120300420042,100100104100320,110404200003201,102101030220010,100020100411301,102001001133110,110102141201112], + 301300000140134: [100002100100210,100010001032223,114321002320001,103020031403100,102200401111200,102000430221040,114003104031111,100102020411200,114200302341234,103002110100200], + 131320010420104: [102101211411000,112032040234431,101020004000000,101004310324302,100102224033421,100120040400011,100214044220201,100400110020244,100124021201021,114011120010030], + 104044310001031: [101444024041143,103020001400040,101023020301100,110200332041001,114004020010203,102100221341001,100011301000021,102014001441210,103204321414213,101004200341000], + 1003001222001421: [102011214000000,110100104403201,102214204040420,103023141400000,101001100300012,100403022201202,110203222040110,101011001031001,111300030040030,100002201032120], + 120000222023001: [112302112020021,112010032340022,100002104302110,110030222130000,101022440300020,110204434434200,102110224000013,110040030001400,114020210031032,100141410402200], + 1010040042020303: [102000220220104,100030004102002,103110114000220,103200021402002,114001200041204,114020114010322,102030401014002,100000020102121,101000201001002,114004220040304], + 1011004302140100: [110104112010103,111102004100101,100122004300410,102202414041044,102140014001101,102000104012232,102021100220101,114443330001442,100230120001003,112042110220004], + 130200300211032: [100210014322020,114010224101022,100030131042200,101203004042010,114221000210214,101410044041001,1144030041011004,111104224102244,103400004000422,103130201421040], + 200010033320200: [111200200000232,101200101021000,100101001011114,101430004040203,103122104002013,101020404210020,114200104001010,114040414014202,100000024301031,101032010322010], + 111222320210000: [101301014221122,114220040000201,102102204022310,111040032200021,114040210022000,100404400013222,112010420241002,112201010203210,100000214310412,103042320101230], + 1112023202030221: [114002104014300,102000311102212,100130320031042,102010004040000,112433112020200,100042001020203,112023032000020,102000201101332,100111304300020,114132420004104], + 1012320020133003: [111112002210022,103222004002001,100003421042112,114240004110231,102024021130010,103200224020100,103013024002104,112012010230002], + 1100000042242020: [100010400022200,102420221112201,101224044041002,100010344310042,102103214000210,100402012200112], + 221201000122124: [114002104014300,102000311102212,102010004040000,102230130203001,112433112020200,112301312020123,103313404030100,101400201014000,102000201101332,102231041120104], + 102000221422040: [101011004212201,110032022002020,100214230430124,103031234000122,100400110020244,101042001021012,103230011412301,101100104002023,100400000010020,100124021201021], + 222402023100200: [112204410414103,100014030414202,102012021131340,100210104104000,110020401211010,114201214142110,100403000022030,112000301120301,103101104000000,101214010302044], + 1400100000000411: [100002100100210,102420424042020,100010001032223,102111024000402,114321002320001,102001011100100,103020031403100,102200401111200,102311120222404,102000430221040], + 224203010441120: [100202221212300,101001204211221,110004022000404,114240210000130,111240000001101,110010012102144,101020200301303,112000111120040,101120204202002,112030012300122], + 1001000013420411: [110432300102000,100011004102400,110040344210011,100003200020112,101000100340001,101300240310420,102100020214203,103000300124010,100030301030114,114211410004214], + 232110311230110: [103211200100400,102112231020231,100022004300020,102320000240102,100042144200000,102030304001101,100020420121003,103020004011414,112002104003412,102211210242000], + 1002131400444241: [100002201031130,102003104011100,110011024414011,103300204014142,114203022320321,114201130210110,104103100010141,111101222240010,103110001420420,102000121100012], + 1200010304020112: [103114204002100,114230004110101,102334021001211,100001101033010,100000001024010,101000304000400,100100014302013,101204031024110,102020204010341,111310000002001], + 1003423010013402: [101112141012322,100100000401020,100211104104241,100103001220002,100400102200124,103000211221141,112201001104000], + 122012300113332: [103000000104034,101022121000241,111100004100400,112310032020303,100020014100010,114230304101022,102423124023042,102421000201200,103014121401311,100400002201020], + 203220132340402: [102122401340101,110021020001220,114420102323300,110112030401012,111112204404021,110404122110112,110403010000304,114100040214000,102412044040011,110411004223302], + 102002323000400: [110001332120300,102101211411000,110003000420200,110243234240200,110004014411012,112000120232022,102041220200010,100002320113100,112240200202201,110020321120011], + 121131020121131: [100242430032003,101412131010213,102020010200102,100400000020210,102202010204130,100032000002120,100424011014010,100003040422420,110202344240014,111101100020030], + 1032234110020402: [101221121202421,111042022141200,101441101010020,102022031321021,100442220030040,112310010200312,100100241020020,100002004342004,103010330100320,101033300332204], + 1430002030101012: [100310120141002,103214010102022,102324014112020,102404021403141,103022021431010,103200020111014,100010004313001,103104200210410,100002200410030,100121031014040], + 1000010140210402: [100041000010302,112004202302034,114210400000112,111321314133000,101131024020440,102031014002010,101000134220400,114030202300100,102300040210200,101023001021100], + 102211000430322: [102202004042024,110140001010224,100000004300000,110000000130104,110112401320042,110020022003000,101011100331002,112030340234011,100010010204302,100310201003011], + 1121320023011220: [101031241000010,110030332100203,114404232310120,103100034001310,114002202210331,100031301020100,110011300010031,110002401102404,102300010221010,110221021202011], + 1103013112032040: [102201000240040,101141104002200,103320300114001,100101000010002,110240302100000,100033411000232,103021100002140,111024112200320,113110032411002,111223220012232], + 124143012001001: [110040112132130,102221041100201,100204004121023,100413304100413,112134000201310,101002401110142,100110130000123,100200201213011,102030000221134,102201032021231], + 111012000214304: [110000112003030,111310220042301,112410434041401,110300024422133], + 1001214121413200: [102300120242120,110444010032242,112220001100200,114014130041210,100001041031013,102430001113001,110224200113042,101000020301410,101041001032310,100042424214220], + 102041023034012: [102310031100100,100000214102101,102230121123030,114020402303041,103000000104034,103020031420410,103100124003243,102033200222311,100002021020001,102000110224002], + 101201000224314: [100030231000344,112311011101001,110100124402042,111120402212201,100101021021114,102120404134413,101100200330040,110040212000010,110211202030440,114440012312003], + 1000201103200131: [102023324010020,114000004103003,111131002212014,102110100233222,102120311402124,101042421021120,114013204013220,102000100221400,114241204001213,100044024200432], + 1430200401000200: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 201034010042420: [101321001000010,101010424210144,102203011120021,100401140034220,100130014300042,114034400040402,100010100102032,112010344023013,114002002300222,102102131340404], + 302000002041301: [101001040340004,102424204043100,112022334022101,101011324004222,100300211000020,101410401010030,103210241422022,103240001403000,102202204040220,102121010212140], + 1111012022001404: [102101211411000,114110200212210,100102224033421,100104101200201,102021001411110,114222010213042,110041102012100,100120430411222,110014314410140,100022014302423], + 1040133013000211: [102131104023111,102420130230104,103000004010400,100000004310002,101021014224121,100012114210011,111301000000031,111200304131014,103020200123211,100000340120221], + 112203022421400: [114430324140000,103100010212020,110000440420040,100402200033000,100022010100002,100043404304202,100102014301210,101011000302004,100041121022141,114233000212030], + 120001010004103: [100001300102001,112033124022002,101013114001130,110110102042312,101004104010020,102001014003100,114121200231310,100110101010234,100243201003120,110010002004203], + 110000202301012: [114124400000022,1104100000042000,1302001134003203,244000303210100,103100240003304,110000011101202,1310001001103311], + 122203001121112: [102342214020012,100220024324023,100214104301120,104130011240303,103400100131022,114100212210001,114143200211211,102320234112041,110402101344233,101001011001300], + 1040002130100000: [110010000111020,102011041320000,114240012324120,100022010022031,102014140200013,101240110302200,100031204311023,101232001021020,100012121040101,101022011003022], + 113210420410210: [114400034111031,234010311030401,110002201200100,103120044002023,101121420321412,102210004034010,112423030200001,101010111030103,100430020420000,100422210013104], + 103010201110000: [102001404012100,114201204111222,103300004021200,102122214131011,100023031000024,103230134011412,100012004101221,100020004101012,102402000201011,102311011000200], + 1030120000033000: [100301300121100,110042400130000,103020124010320,100021300101201,104101201240100,110000011012202,101244324043222,112102232300222,102000020241101,112311000204002], + 130010111420131: [114212012310002,102004004002321,111301022200213,114002114102311,110000230010221,110310012024144,112031000230000,100012024301000,112012240221124,110302300040021], + 1002200021233411: [114024002200340,1040124303014404,131403134400030,114211022324201,421004021010044,403114413114010,1300214003010004,400010020041221,1020104432243040,1301111304022013], + 1030123301010410: [102323101101400,220103022224020,101230330042220,1304100402114410,410142111403201,1002022230124020], + 1100342212220312: [102300122004231,102321401000212,102042444010014,102330311004110,114032110040320,114003440040210,114423100000411,110040104210200,102442300230020,103120010100120], + 1010021402000102: [100014100100001,102100004130301,111120004100414,101034024000101,101243024011000,103033011400312,103340410140122,100010021221221,111012202111021,100103144302200], + 1032003300010022: [100140201011204,104010100010424,103010014013304,102103030201001,101203104200224,100010221031023,100140000024021,101223024200014,112240404012020,102000220204011], + 1004030022200104: [114410024110002,111200210001023,101101401020424,100002200100100,102032022000041,100020000120134,112422100200404,110202001212002,102342022000024,114000222330121], + 1002334042024203: [100000041040000,102401141113031,103042420143020,102304314110202,110210400002012,113032012204012,100002134300030,100130414300000,112310002020302,100204311000400], + 141310223100102: [102211220201114,102101004030220,102003001132213,102100204030012,114041040023020], + 1030113101412220: [102043200200021,1020000323020202,102310100201021,110230121300210,103020334003020,103024401243320,101100400321330,123004100001230,102100430314220,100103011004230], + 130012011302123: [101020210300204,112203122042414,103021210110121,100000401020012,110203100002414,114002100002414,100200321001303,101211011023023,102102030200304,103020224040304], + 102040033020001: [102213210210004,101220121101403,112210141104023,234010311030401,100003030202011,110103420020232,100010041001440,112423030200001,102302421103304,103220010130113], + 1040020123000011: [110401004221204,100322444314002,100001030100030,112012004004000,103141100104002,110341300400201,100000104210240,100224010102312,111120032213101,100142201023312], + 311204310140201: [100100121041013,101401211012010,114000010041320,114120204003101,114401322310000,100000000101012,101020230322012,102103120200023,112004302030010,102100001400332], + 1031313301002322: [102133404134022,130000220021033,1040014000334201,100020110003100,131114110030130,1120023242400240,113000343131000,410120000124111,413200300004130,101310000020110], + 1000322112203200: [112004001122300,101301124222004,114010204101202,100041234101100,112204220200011,110013202120001,100230040410200,100211211002001,103210004031201,114142200220014], + 213400103001001: [131402001003121,100440420024144,114420000001024,102030414000201,102402000202120,100304111000014,103300031403210,100022131043110,102010021413001,110010001011032], + 1000002010004002: [110104112010103,111102004100101,100122004300410,102202414041044,102000104012232,102021100220101,114443330001442,100230120001003,112042110220004,112203221102231], + 1440340020021130: [102030004002200,112414102011010,110014012001011,110022410420343,100100410401030,102000040222041,100400430022423,100201314104221,110420200000430,112323332001000], + 1044422001133000: [110401004221204,111112000011222,102403001342000,100322444314002,101003301020022,100400020033040,100102431021300,110200212041001,100001030100030,112012004004000], + 1110113020400001: [112021201120101,101142124022010,114202002320113,101000104002203,102430001401230,102103422004103,100010024202200,100020004212223,112101002304200,102102021143222], + 1130110031113040: [100020120021020,103001101422010,102014400223314,111012340040202,100112304000043,102100411121420,100013014310022,100002210000012,111001400043101,101414220302220], + 1020032401220203: [100023421041402,101010224000130,101144134001102,110012220002021,100210020410010,114034422302101,101000414002041,110421104242000,110220302043002,102322004112023], + 133131004200044: [101022014222024,100032000101014,103030104000102,111311002224001,100032134101100,114201024112001,112010024023002,100000421024110,102130314134001,102011211102101], + 1133110320024010: [114040102210432,100034004211240,102140121410131,112040200233002,102113111343110,103234100101221,114002220010031,103103311424020,100001010412000,114000304104142], + 1040030403040020: [110200004243223,102000010200200,100033400410104,110210001310230,100010144303000,100413300430300,110020122000000,112020402001012,103144401421000,100133404030004], + 103001001101000: [101001040340004,102424204043100,112022334022101,101011324004222,100300211000020,101410401010030,103210241422022,103240001403000,102202204040220,102121010212140], + 120402400010003: [110000001324024,101020111001331,101000001111200,114010040023411,102300404024300,102110001342011,102001010222103,100040041020102,100000101030412,114420142322140], + 130200040100400: [110021220021121,103322424033024,200003230020033,100010130140100,114101104124300,110040000440000,110010010431112,102103201412111,101140114004004,110210004212240], + 1100240221002300: [114313304002310,102004110223232,112204010411101,103202404003021,103211010211331], + 1000243221002300: [103202134021411,102321011102100,100330104310102,101101000331232,103120234000102,114011004123232,114402022314101,111110002102202,114001000022103,102012102002404], + 130000120101201: [101212000301013,100000211020034,101000000323000,102024034002302,100200321001013,101000124221041,100022214202002,113000020120100,111202020012102,112031000210110], + 1020310142120200: [102121221343020,101010101022202,112104424022201,100013211002142,1300034431310021,102210104000000,111023100040110,103113224004201,102211204000440,102203211104211], + 1122101022242012: [401142101000022,1342140400001210,1203210010100211,400114001102410,111011220004001,431232000323104,100221110031000], + 103124002412324: [1020102233442023,110001440000224,101404203243201,1132012124324031], + 203214212220130: [100020014300000,111000302200441,1340223401102011,114100200214010], + 130440124000200: [104120011242011,114300000000002,110020002104100,102111400202120,102000301101102,111400214442024,114100124002210,111122200021102,112400034040002,101041100300001], + 1400120100004432: [101440004041120,101031214000041,114112020212203,114302020003041,102110014030002,110201200000101,110110000032030,102001200204101,102033340222200,110042402132412], + 1020013040344222: [112121214040022,102401221402002,102102011342302,102140200224200,101001244010120,101030224004130,100000030120242,102110400210023,100004020411201,110144100400420], + 1000320121000120: [100003011041040,103200141404212,114001112300222,100203141001002,114122440000024,103000020103121,101200024010043,101044211032201,100011111032203,103021440122032], + 1044212030003200: [101001040340004,102424204043100,112022334022101,101011324004222,101410401010030,103210241422022,103240001403000,102202204040220,102121010212140,110020124200230], + 120213310220222: [101020414010211,101120204002140,101142004000232,101020024002022,112002112002220,100012304300004,100400320013200,102041314012004,102010001101101,103001314000242], + 202310110441022: [112142301101040,102340221000300,101121100332142,112401314040311,102011004013000,111200122222334,100220124221000,100402002201002,100033230420102,111110004402021], + 120013000200101: [100041204212120,102113110210240,100341130142101,112423424042102,100320431000002,102100300210100,411200101402221,102440100200000,1302011220000002,100401430030420], + 104300002140120: [110012031011302,111200104411001,102121200313040,111011104401124,100300021202320,110334102021144,102224202023120,103410414000011,111212120001103,110201102230003], + 1001221003044032: [100440104303400,102122000214201,102220241100202,102024240221040,110320011200230,100342024100204,101422034042201,100011114300334,102300001002140,110040122000002], + 112014040222200: [100214121000000,100042034200032,102011041100210,114323000000130,101400240300010,102412241111002,100424104302020,101013234000010,102002010224011,103210014003000], + 1000434104411110: [100312331004000,103301244010210,100101031041022,100000240003101,103001220100000,114124420032020,112012012002100,102314001000244,114100000031020,100003124211410], + 121001011123100: [100003030003020,110410000104042,100014014203233,111422100034314,100000040413000,100001034310012,102030414003000,121310232003222,110011300143002,100220021000033], + 1000000302320041: [102112432004423,102402124022000,102032204000102,101001030310014,114222122332021,103004041410020,101004004211001,101002000323021,114000000021014,110200202231210], + 1043002012101012: [110013202003320,101031241000010,102120231343224,110030332100203,114404232310120,103100034001310,114002202210331,100031301020100,110111032140220,100020010200022], + 101021202010042: [114210014110000,112020042344001,111101122102222,110034004420011,103000114001000,100003344214000,111022214113044,102322420210320,114124040000002,100112001021112], + 1000002002141314: [100214230412031,114022024010120,114210204000010,100202400410110,103021004001020,110223300010103,110202024432022,100111141040220,113004400141240,100043004101001], + 120334102130204: [101242011000124,100202340430142,114420242311240,110141001301302,101200200300310,114011402303024,112124000203110,102020004000040,100020030104002,102110201342301], + 112130414022120: [110021100023210,103122000100403,114103412201420,110014300041302,114241000002004,110020310022021,101121021020012,110321001330010,100000300100000,100400214321121], + 211320022102003: [111200200000232,101200101021000,100101001011114,101430004040203,103000024014022,103122104002013,101020404210020,100001001021002,114200104001010,114040414014202], + 112100210130102: [112004012000201,111312014124200,110132211004000,100022000000314,101103044002141,101410410301140,114103234000402,114140020210200,110201002224022,112002101122002], + 1000022024020021: [103122020213112,114101100211240,103012011434022,101032010342004,114102102344110,114010002300003,100112110020301,100000004102124,102000034013222,100022301000112], + 220101402120102: [110102224201130,103301201402204,100021020124002,102104131412412,114020312300021,102400204043012,114010102300010,114042014014024,100000000200102,101011011000320], + 220440442104101: [112142301101040,102340221000300,101121100332142,112401314040311,102011004013000,111200122222334,100220124221000,100402002201002,100033230420102,111110004402021], + 1021100114242002: [114032104100141,111140100011101,110122421241103,112001144002010,101013030304101,100012011022000,102000004000013,102021241324040,102000111102000,102300441002012], + 1002430021400001: [100022024212302,114104002204400,100040410000030,103203400100320,101211311002032,102201210232332,110202032123200,110231200114010,103210011413012,112411014041022], + 1001204122440221: [141000211410012,110101322000312,100100001004210,111101104101324,110111000003302,111044114411101,100124114331032,114110220020020,101202110301231,110100022230000], + 1021001410103041: [400124411000212,100002010410120,1321022130413330,1302001134003203,420023000041240,104231102420022,244000303210100,110302040021421,1420221102104240,1001443041410021], + 1101000333002042: [111102110012000,111142010020301,100031201030331,100000144104100,101000344010212,101033141030001,100104400021023,102111210230204,101003400322022,102200421003014], + 1111002020002210: [1200300001400200], + 101013202230004: [101202000300323,1202120201221210,110400323041022,1134000004202341,100000144310420,411011320001004,1400102001010010,1002004011000420,110004004413303,114131042311202], + 1020001020041134: [102334004110232,112200102024122,103000034003300,112300032000100,101000100322140,114010010002314,101120030010320,114124002341030,110302322102041,110322210100140], + 1140322000311402: [103442110132330,112010420232040,100032114202001,100220410101001,101023024210000,102140322001242,110000442001100,110201401201230,112013124020300,110000020440133], + 102430210141402: [112004000212242,101002030320032,111410302212101,101001021001221], + 1012140012122241: [110220122044010,110042304412204,114020124021122,100002201003312,100110214103200,101030320322101,114140002313010,102230121120000,103300001402013,122242202003000], + 1101403140140000: [100300041001121,101240004011021,100120014100010,102303030241010,102202144110114,101013220320021,103002020142122,114231042331020,114200324004201,102010424000320], + 100100042014203: [100231401213132,114210104113314,114021232300112,103001000120444,101144024000232,101302121004422,100110000000000,100000010011430,100114420000140,102320021100120], + 1243004213402001: [102304030220001,102141124004222,112042422001032,101010001000432,100134101022112,103310200110020,100020031030323,102140041342001,100001001032400,112100022010403], + 1140110020021401: [114020000011320,111020032203301,100031001030010,101000210303342,103433144040432,101440400302320,103000121424330,101204004040140,102111021022024,112010222001103], + 1132400004020033: [102223111000042,102320200221110,101000410321210,101040401032021,114200004110030,111102324104110,100030124212213,114210102320112,102304331000110,101301420312101], + 1022020414111011: [103000210120000,101211031002000,111220000010211,112010122302144,102141002001403,100030101031100,100011244102344,100101020412042,102321034113010,100031300101240], + 102243002344030: [102121201340001,102200211120103,110400242110410,111302204123234,100030020423044,103013104002044,114211004004210,100034204310001,111202000003000,110011340001104], + 1030132020032001: [110004020020022,100043010120010,110030110122402,102143432000102,101031001004201,102040010200101,102200434012013,112000301122111,114001110033210,102013120200110], + 1000404024211431: [101204400304011,100020440122040,100301020420101,102002202000000,102101414130243,100040211031313,103004001400210,111100034100301,111213002240400,103003004044030], + 210133403121024: [103043404000202,101001400301113,103101024004200,102014111102023,101301014220002,101012044004042,112410300200001,102020304000321,100021201020001,100112240020023], + 1043313043423032: [101133001104410,114202424001100,114113004120221,1100000411441420,1002203010011112,101211011012300,100010300121240,1012004033012200,402001100011120,100020321030202], + 200234040022202: [110020100042220,102123000230200,114200302320443,100401111000221,103302010140122,100010001001122,104240202023232,114030204021200,114000022210140,100141321000100], + 1122002320000201: [110102224201130,103301201402204,102401121113302,100021020124002,102104131412412,114020312300021,101320040302031,102400204043012,114010102300010,114042014014024], + 1011100022032120: [102300001002440,112402034013000,101011020320030,112202040411432,110013020024300,112101120201010,114124200000414,102010211120200,100400202201400,100403120013010], + 122100001114100: [102000121122000,110011424414202,100040011023003,114223212320410,100000010411010,110232011000001,100130004033423,102111301413000,101002120323040,111000212203022], + 1040230030404323: [100030324200410,114202244112111,102110202001010,114200020003431,114041002212302,100043200102020,103332044032320,100212024322044,100140004102001,114101024122320], + 1011120021000001: [102342014111202,114040002330341,411010033020221,114102020422002,1224320120024001,200002003223300,100224410030410,1101040131142040,111100001002113,132220124203004], + 214002020133001: [110202012100020,110013202003320,101031241000010,102120231343224,111342020011220,110030332100203,100314114322101,114404232310120,103100034001310,114002202210331], + 1423020021400000: [102242304042410,112032012004300,101001034002001,102000014004040,1010120030012200,101024411001024,221104221024023,100010410420002,112000034000041,100202211200032], + 210402131102001: [102040431121110,100400002201113,114111100021420,112024212301420,102212000200124,100300310140241,100240134323001,102111024000402,102042000222002,102001011100100], + 103340001102200: [102120031140142,101010224000130,100404410022320,102220220201011,100222044100141,102134144003010,101004020311013,102210304030340,111302024132000,112134124001023], + 1010123012002033: [103004201421221,1331041104430100,100104114230000,100202004104140,103020441400230,1032220014300112,103222400100400,1002200000203001], + 1002004140011141: [112012111114213,102230004030112,100100221012100,112102000202302,100130401022113,111103304400022,114112402340003,101000431144041,100341101003203,100400230022124], + 204200441000000: [103130424000200,114010204012441,110012031224104,114000240030002,114002322300200,103244034020020,103201034020234,102422010203030,114013402304000,114043342241044], + 102034001104300: [102112121341220,110030004200002,100223211000000,112031110240010,100100414230101,102140011120322,112002220230430,110134022013042,101320231003040,102110011142012], + 131301024120302: [103101224000011,102200042000104,103002000104400,103002144042123,110114021000012,101012000320441,114124414000000,102304204110040,112020004002110,111221440000011], + 110011002000401: [100310120141002,103214010102022,102324014112020,102404021403141,103200020111014,100010004313001,102010200221000,103104200210410,100002200410030,100121031014040], + 111000342102030: [103222004002001,100003421042112,114240004110231,102024021130010,101244001000204,103200224020100,103013024002104,112012010230002], + 101230221310100: [100043014203003,112230024010203,102032114021101,100131014234134,112202140201200,110213000004112,103002011433141,112001124000003,100204004122414,100003234202001], + 110213311302121: [101042410301221,110432300102000,100102024100020,102304000210204,110040344210011,100003320401100,100020120101000,100003200020112,112143144020012,103231224012042], + 102042113001310: [102442411400220,114021100031031,110200131210002,112011210220001,110001001020401,110022000020132,101100014000041,102442340230020,111201002222001,110102000022000], + 131100002301141: [110302302001423,101010101022202,100013211002142,110104000024100,102211204000440,100200001001420,114141024004011,111030424400000,114140044002043,100031101031110], + 112030200001000: [100141220000211,110042202002303,100320011001200,102002344013100,110002002200300,111200302214000,110443002010003], + 104001114001030: [102102241341004,114002034102120,103002020101431,102020431101132,101404104000404,102030011324204,100001024102120,111100022244144,112221201100134,102322014112302], + 1040331033212300: [100000100100200,112041031114021,100140330020001,110400240002411,110030001311103,102232104040041,101002424010442,101220004013020,102302041002022,101400424021221], + 1042421000002340: [114032104100141,101213114040141,102210101002412,111140100011101,110122421241103,112001144002010,101013030304101,100012011022000,102000004000013,102021241324040], + 1000222014242301: [102431111110001,1003002030122040,1320124301012211,120204110000223,1110002442211200], + 1001002101100000: [1440100023013130,401210002011000,1014200301032410,1103013112041021,1001102321230101,110200024240110,140320413003120,121000110000222,400014401213001,103000001421223], + 1131200314042412: [100400002201113,102420424042020,100100000422320,102100012002000,101320224220103,101302131002410,114140120222220,102233200213120,112020020234202,114031030020422], + 1020401222100301: [111101144102000,102110031342012,103211324003020,101010020320000,102300310242221,102024101321401,100402132200000,114020000020300,103000001401041,100000134100202], + 1000112304314214: [103034010121101,101440004042202,114201000004122,102422411113113,102201024041200,100100204101010,101223301020130,111141312211004,100341044310403,103002010121201], + 1422103031100402: [101001400301113,103101024004200,103024000103302,103300021402104,102014111102023,102102024000001,101301014220002,101012044004042,102020304000321,100021201020001], + 102010401201111: [110132031134031,102300200220002,100020314100010,404002010120214,100100012111201,1001412211040002,112100424020221,102102001341100,1304032042210300,103144011212002], + 120300001000010: [102011201101012,102300304110030,114412000003141,103020041420212,100112011040011,114033300041020,100401024300321,100102030423010,102101004022104,101432240300300], + 101003140222100: [102012300212321,112400202023020,104400100142023,1320024233112412,102230004030112,1002022012411300,214021333002200,1200301010403420,112102000202302,100130401022113], + 100320020020201: [110113314221413,100040134340044,101123031111011,110120424221121,110240411110010,110001000142403,101022011140403,101401211012110,101000011010204,114324022300000], + 100211000031004: [110003032000110,100120014234012,112011002002110,100331204212000,100000211232020], + 1420402000300204: [111102110012000,111142010020301,100000144104100,101000344010212,101033141030001,100104400021023,102111210230204,101003400322022,102432201112110,102200421003014], + 1004021011000000: [100030010011002,101021301022041,114410002324204,1043303323011400,1140104002020100,100402300013130,104402130010100,101201220402420,1001120000022000,400040001020004], + 101203100100022: [1002022200102230,1012221001334200,112023142311002,100000030000011], + 1000223000204220: [101221121202421,111042022141200,102300220241031,101441101010020,100442220030040,100100241020020,100002004342004,102312200240012,102012210213203,103010330100320], + 1021202440220002: [110241024242442,102300120242120,110444010032242,112220001100200,114014130041210,100001041031013,114212102310100,110224200113042,101000020301410,114000102210200], + 1200024201401030: [121000042140301,101404203243201], + 122041022231143: [100111011011011,100030040101021,114310102300021,114014112300100,114030034013101,102400124020001,100102224234101,101013004001421,103000014011004,102010321411140], + 132020211002032: [100220034322312,100203104322011,112002224004011,102110000210014,111101142110100,102000411410342,102310314114031,130200211400203,101302031000033,102020124011141], + 1041031242330420: [111300210014020,100100031043410,114001100024243,111000142201220,112102100423402,110141112044000,100034244303010,100120000410220,114100322342010,102000214002210], + 1002440310320031: [100440024301100,101023221000031,101400014040400,114101000221221,102013000202010,100031130410243,100110204101020,100010000201210,103222221410230,101233100303204], + 100000010004433: [114112124140000,100000021023020,100100220423210,110044220021000,100231020112302,103122411441211,114102004002022,101110204004210,103414020133020,102022121324011], + 100043200100130: [114400022321400,101302340312230,100011101222101,114304212302401,110021324200010,100401200010140,110040142002100,102300001102240,102312021101141,101010001022001], + 123243200040000: [102011011131130,112402032010131,112310431102204,101010024213100,102010001101021,111122004100320,110001122003123,112100204002200,110143012040201,110020002102332], + 200410030402211: [100402400013000,112340002022202,102310044114012,110101004223000,110300400000232,110000002010200,100130014234331,110030224201200,101022441110111,102210000313010], + 1101020022222031: [100100021043102,100010141222300,114302004001202,100100000011011,101240311010402,110020001210223,112131000201420,110230032120002,103010100110112,111014030043044], + 102332002003200: [100023240103222,110021000110000,111111224130002,110212310002021,103010334000010,110131222010140,100010000044200,110202001111010,101202240300202,112112034040112], + 1113102102202000: [103220011411101,114220014111304,101030301000221,102003111413120,100023101043203,114200122340300,114201022330011,114020420030200,114143024003322,114021444010222], + 1121000204302033: [110144240011020,112000244001222,114441114123013,103220211421421,110123230124040,114000012334102,101000014012442,111022210021013,131000001020102,102101214030204], + 201011020101103: [100010400022200,102300001002144,102302444110110,103001000142003,110310004424232,100402012200112], + 1012300422010310: [114300020001420,114133230000102,102234010200304,100001021030011,102200100204220,103200110102141,100021030100001,102203301003030,102334201001100,102010104023003], + 1444002210011001: [110010100442102,100012341220120,102130014134000,114100242200433,100010114102101,100041001020232,110133002013103,100003044241304,100004204211224,100000220410320], + 214012400114202: [112142301101040,101214440300301,101121100332142,111200122222334,102301024113440,100033230420102,111110004402021,100000030000001,112032420240110,101104120334002], + 1102220101212100: [103012034041202,101201111200422,110322311300120,103340404020014,110010204204104,110104101003002,102100040202020,101333011000041,100032131220310,101201101022211], + 1411044011011022: [110140001010224,100441301014410,114001024010010,102101224000013,111212204420203,110020022003000,114230020000033,101012004002440,103110400120002,100310201003011], + 112110003040002: [102440014022301,110302204420101,101000001110403,102000011102224,102111041342000,102303310241230,100221101003420,114241200001240,110010004211300,102110024002001], + 1100032034420030: [114441040001202,114422000000123,100010330010200,110412000000421,110221004213100,101112314020004,101023300320033,103100020121000,102220104012021,100143204020213], + 1001123001021002: [100402430032210,110202222220410,131342330212024,114111040212210,114030120000104,110211000022421,113000022402120,120000211034230,103220001202000,111242022222024], + 1040110010301041: [100011201020234,101221000302204,101040010311213,114100200002111,101000034210022,101322201001022,111212010004002,112420042020110,101022310300133,102110120210211], + 1143121040001241: [100004001021111,101021004214202,100003000104203,102114320203000,114001112300001,101003104212220,102311110240101,114002002300302,100000304301120,114130210000231], + 101002002112013: [102000100202041,101021041001434,111200024131220,111203034440323,100112401020300,110320222000043,114101000210402,100100000400120,112000211131111,110103431221000], + 1013040200112002: [103321411401411,100042010200121,101000010300200,101022220302103,111010200000412,100004300100000,103013241240202,112010000243420,101010001000231,103032214000202], + 1000332100000000: [111000122201420,104134121240044,100011004102400,102100020214203,103000300124010,102302001000120,100004120101032,100002221040242,110210044431141,101112030300043], + 313414212313021: [100412400433000,101120001042201,100003310142001,103014120104032], + 120003100340403: [110022000023010,102410141403032,100003214201113,100013000204021,100100021010323,102001000221040,103032400121000,101004104002142,102221000202231,102101210234111], + 1120041023001012: [114200044114004,102202010204130,100424011014010,100220101204311,100003040422420,102100430233212,101010224210000,103003210141014,110421222011222,100021100002100], + 103013440000011: [101011220324041,101300000310200,114220110001121,100031004311400,110020011223233,110013000002041,102220004001014,102141302001013,100401302200302,114200102320214], + 100000210010211: [101133001104410,114202424001100,114113004120221,1100000411441420,1002203010011112,101211011012300,100010300121240,1012004033012200,402001100011120,100020321030202], + 1100011011112232: [100220100110400,102403004042342,101024001034211,111122004101222,114020040013100,114001012300002,114000222213021,114102330210021,100000020401302,102103214000210], + 203202412301230: [111020030040120,110002000134011,101122040304410,100302121000100,112003402002003,102000104003032,111011402203004,303020404011031,112011114002003,102012044013241], + 1144340003301012: [103211200100400,102112231020231,100022004300020,102030304001101,100020420121003,114201204111002,112010122302144,100000114103021,101310000310240,100120244301401], + 240231221203204: [102001404012100,1010400230221020,102302200210010,102340120222440,114223204100010,111041202200140,111300400002313,111101040014040,100023014313010,114021040010311], + 200220344200022: [114110242200201,103002020101431,101404104000404,103020031420410,102101220231020,112220020204222,102322014112302,102110114020042,101432044040142,101000220311120], + 1101202100011414: [100000100000432,114200104110001,111220100000032,114214040002011,100121324230300,100121111000220,100113434000102,100033320410000,103001424002424,112021410241120], + 1002222010200010: [102420101111121,101222041041012,100032124210042,103222000100010,100100000021020,131213314114102,110020000000320,114010024020443,120011100321000,101210220304010], + 1121140001000134: [102024001120110,110010002034300,102100042002040,110230402031010,111420004443424,101020411114000,111330024132300,102000310203004,111114332100303,111040002143023], + 214000410443000: [110000322130121,101023001002020,111300222202234,100200001210021,103204230111030,104130020011020,101114422122000,102001314013400,114110414140400,111201100011141], + 110010211021431: [101011000322203,110241022112013,102110010230101,102041004040002,114423004144120,101010024214000,102203000200001,112424024010030,103014044010100,103224004020021], + 1113113011034412: [103211200100400,102112231020231,100022004300020,102320000240102,100042144200000,102030304001101,100020420121003,114201204111002,112120214020030,112010122302144], + 1102211011314121: [112300212023031,114144004124200,102000121122000,110011424414202,110000214202000,100040011023003,100123031023104,114223212320410,100302114311412,103000004044020], + 112220142032321: [110104112010103,111102004100101,100122004300410,102202414041044,102140014001101,102000104012232,102021100220101,114443330001442,100230120001003,114000040010421], + 1020011332020310: [101232314010241,100301300121100,103020124010320,100021300101201,110230022122031,101000444214021,112102112301130,100414004300100,112102232300222,102200000201120], + 120200002310401: [102404004041224,102200041120220,103220010101140,101140014001001,114101002200223,1034110304101100,110021041330000,114321140000202,121102001120113,103322000111220], + 110000010320010: [102100304000010,101240100304114,110022114410310,102100110210040,110310124400123,110000040022323,110201400000100,110400204221003,112000000241102,103001001422040], + 1201301200001200: [100000014100202,101012104001020,101210120302002,100140004230101,102000304001202,100010300121000,100001314100400,110100224201000,110140001120211,114010104100013], + 100200402320001: [102221200204022,100004014300341,114100212211004,100104234230043,102101024000110,100401301001200,100110000414024,100011104104000,101234041021200,102411110232201], + 231021100222211: [112102202040000,110100104404110,102110042001043,110200200400310,114100002204212,102003000212104,102000100220240,110013001200012,102030204000041,102110021341014], + 1020023302031401: [110433012110300,110440201342022,112243340202002,101000204003420,110101240024120,110300310011030,100230101001020,101440130332003,100400024302030,103100010100001], + 100244010012300: [112113214020100,102010202004402,111130312211003,103224041400220,101001010300404,103340004020422,102410220200004,103113010102100,101224044041002,102211430202033], + 122201001302000: [100001311221321,111012024112012,112224010200122,100402000022000,110011242202000,102213301104400,113030342402110,113000141022010,101000331020102,110340342021001], + 1112002214041102: [102102000213403,100140000410014,101041344000400,100020420123031,102412020234414,102202424111200,102100040220330,101002424214013,100012101022110,100400222200110], + 1400011312102034: [114102300004024,112102201102030,103222244003021,102420011111224,110232020002221,101000140310132,100001311234020,102013102002210], + 124041141201002: [110201320000011,114210000004140,102030004000212,110400121004031,112214002024310,110441014220002,100404322200002,102000331322102,112402122020012,100302024101020], + 1402040010133140: [102004204041000,100104341010424,111020002202333,100002320411400,101000100342143,103142210104020,114400240003003,101022001002030,100002104104001,103302030111430], + 120002440100022: [100000110410000,110211100000033,101200000304000,112014402034232,114222422332100,102000000211031,101400221012300,102110000210220,114333212323001,114102300220012], + 100033320110020: [114020024104430,101343331004220,100140310020221,103110440210000,101204044010203,100123200410410,112023230230101,100403002201210,102101404003204,101020204210110], + 1013300211000002: [101001000322303,103120004002000,100021441032202,100031000422032,102404120202300,100001304100000,103022041401232,100213114342042,100002401030040,100212001002030], + 1042032400230001: [110120144200000,114022412330004,101200221022044,101041030320401,110241112020204,100002004104004,103130021444021,102100104002224,102100224000210,102103321411004], + 100000320411041: [102100200234203,110203204241122,110001214200042,112002242001000,100021111211003,100010210101012,112010204003014,102032220221210,101032240320040,112001302302020], + 1112124202104004: [102003004000040,102011101131021,100021100013401,100204011000000,111010110042210,100114200020220,114401004122120,103123200101000,110023031204100,102431411400001], + 120020322311001: [114000034010043,1040014000334201,110220210110004,110221401304401,102220000230020,100111204004442,100212211003002,110420001101321], + 1023043111021124: [102213210200210,111010014440002,102003001104112,102202121121022,114244024112212,100140110020002,102004110220430,100040211020022,102402220203024,102011330201112], + 222004010332022: [111103240020200,110022201100020,100141214304000,101430001012430,100011204100020,102410220200004,102100211340043,112100311104022,103443104001332,101422214042012], + 1002001131430213: [102041020220100,102023031321010,102220020201230,114010214013020,100112404231200,102303021004001,100003001021410,110220122022202,102001024002421,110201020010102], + 120033442003020: [100122004300410,112100124023402,112400202020003,102000224000011,101212040303123,101020044011003,100030300124130,100001100013110,103122000211420,100032301041204], + 100104130044021: [102041004012012,101420211014000,100344224100402,111000012222023,110401230001013,100230001001032,114212102341020,100023001030203,110031220000101,110402102112223], + 124400422041340: [112002002000410,110111041011032,102221230200001,114100212200003,100020010022143,1341242223200002,103001044021102,100101141010322,100023201000300,100000044310330], + 1121100002001103: [110301222101110,102023301102400,100030414300112,102012204010044,104120110010402,111010214402000,110401440001204,110204310112224,110303104423010,110340022023321], + 102200421040121: [110401004221204,111112000011222,100322444314002,101003301020022,100001030100030,112012004004000,112044204000441,103141100104002,110341300400201,100000104210240], + 120100140312100: [102001001130100,124020002020003,122222120003214,133332002141010,144000013213001,124010030100142,111032444402403,110103201001321,102011420200123,102311430211100], + 301000320101102: [100010134300002,110232320002010,101000001031130,101202444044002,111310200002200,100121044230302,114014410023000,1021042101032324,102201301123243,103000200101010], + 242402320041410: [100000044204004,101020224210014,114202244101041,112423102010012,102112022001414,101212214011134,100001121023210,100012101020002,114204120000200,101424010301210], + 140220021012400: [101030014001004,110144102001321,100020304102100,100013010004000,112020022000410,111232100010040,100010004203011,110001420003002,114000202301203,101202200300020], + 1042310240200011: [103212424020104,112010140202000,102001020220240,110344041332022,111310002200011,110020200120001,100211244340000,101020414001030,100102001021001,103402204002011], + 122210200410001: [102424204043100,100113220020101,100300211000020,114310200002400,103211220100010,101202201021310,103044004010022,114130020222342,112301032022414,102103100310300], + 230000101110231: [110100201000100,100001024102310,111111024404430,114200020210110,112211402032230,101140301101104,100441431010310,103313134024222,102202404040003,110031330430031], + 103203000123410: [1411024442020100,1002230121400101,1004130302142412,100100001004101,1301222204300302,1300100202010022], + 310100000202000: [104100012102004,110021232000021,100401241014100,110301322104142,100001140000010,102003000212200,102420020204200,102000200222121,110033002000020,110343014421300], + 100240322411304: [102210100313100,100004420014012,102240210240022,101040401032021,114200004110030,102024124011010,102000324013042,100030124212213,114210102320112,114234004112000], + 1001440003002000: [102200130202201,102414034040100,100212030414010,100412200002013,102133001404002,102020041321410,102300020220011,102301324112020,111340300010010,102400101111034], + 1102104011120220: [100030324200410,114202244112111,102110202001010,114011404103142,114200020003431,114041002212302,100043200102020,103332044032320,100202121000302,100212024322044], + 104044020014020: [102000402041014,100142010410011,102041410242244,102101220214011,100022010411004,102323201000412,102212434110001,114240044000100,112102314020000,114010002304030], + 1020431032314000: [100102224234002,140102120200000,110400444243022,110131001002021,203201100012000,122001000320022,121104330112000], + 1202430010012000: [100120204003012,1100440001000000,110202102121400,101000040300001,200304020022101,103400200120410,102022034012314,101443040303302,233002100331010,102432330000101], + 121004320240100: [100021014100124,102012200200030,100131024303001,102203314011321,102231114040010,102314022000031,114023034100101,102000214011041,102103120200023,103010300100303], + 122002442000024: [102030004002200,100040014210402,112414102011010,110014012001011,100402040012140,100100410401030,102000040222041,100400430022423,100201314104221,112323230202030], + 1000120010042423: [101020411140204,114203410002220,110312201002000,112000014000010,102201321104400,100131000010024,102101421120103,102223100230002,100140104103041,112103232310200], + 130201214001032: [112020000230440,110041014413112,110004002133140,100040031020241,101100104000222,100411400030100,100002000102100,114340102322021,102120221120200,102100211143330], + 243420000000000: [110102042010220,101020124000413,111210000001101,114013400011030,102202000201220,101020111030400,103004104010210,101220024041000,102010300201414,100202200003011], + 103232013004010: [114042304100001,102210224012020,114313302321311,102212300202110,102210304013310,112101020200032,112002002030004,101220000302410,100024414212001,100004210412101], + 240224001042004: [111104102242110,102210011101414,100002200410230,100044010200300,102102011401410,114032124013234,102143020230411,100102014301210,102043024010103,111133102212220], + 1000142401001012: [111201032220400,100200004301323,110041002130210,114203000004300,112401024044240,100022120412132,100000321031423,100031220121003,110322100104010,114302102300200], + 102001002413010: [104120011242011,114300000000002,110121100004131,110020002104100,110210014220001,102111400202120,102000301101102,111400214442024,114100124002210,111122200021102], + 104204240243134: [110320442100100,103022421400100,100030000104003,114020012204013,101020224003300,114422000000001,100411410002011,101200220300302,111201310013231,102100101320311], + 1022020201123203: [110213120001100,102040044001211,100220301003101,102214011111010,101003041141301,101120100320100,110310130114040,114140014100000,103211001202110,103121311240102], + 1001110041211001: [102102000213403,102334000243030,100140000410014,101041344000400,100020420123031,102412020234414,102202424111200,102100040220330,103040001430220,101002424214013], + 1012201010101030: [110103341120422,112122024023021,101000021020100,110042022001000,110104112012000,112001204001021,111220102222123,111101220010010,111020004404000], + 130110401024000: [100010201030300,112420104040020,100233014224240,100403430013124,102030001131120,102221414000020,110110200001000,110004210004223,102302004110231,114224210210310], + 1001120112130233: [110320202023400,101000304014100,111431110000042,100302141003012,102004441124110,103303201400021,114101420030202,101123232010002,114421242204443,100000301221024], + 221010001010100: [100032041021210,102300324010203,102040011121100,114310000001232,111322234130000,102040041320010,110104002010100,100030024303023,102042204000300,100001134100120], + 1021222040101042: [110120144200000,114022412330004,102343230224321,101200221022044,110241112020204,100002004104004,102310140240012,100014204201000,102103321411004,100400001001300], + 1003021311121402: [102310324112030,100410130030232,103220101421001,121110020100002,100002104204000,140004230143221,144200400000000,103321202010002,101124344200400,102021220202100], + 102003241000110: [110401410402040,110023214202401,110232202123140,110022040430124,101442404020304,100214401001202,110011000042000,103300201404300,100222100432020,101423434023101], + 1020034311314120: [100024000110221,101000130320340,100110020031042,101301014221122,110422102110221,102102204022310,114130014001202,110010220103020,111004100022110,101002201140040], + 103013110312104: [110200002031302,102002020243020,114002002300201,101403220331230,102040021121030,100311314310000,100000204130001,102041130200101,100412441010422,102130224131022], + 114100120300110: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 120340020411044: [114410024110002,111200210001023,101101401020424,100002200100100,102032022000041,100020000120134,112422100200404,110202001212002,110001014204010,102342022000024], + 1144121210002211: [100000410103200,100001240410410,101042201000011,102030001412241,101001204010220,100004301023143,114223200221140,101012400304201,100031044300340,103212014020132], + 1000101410001201: [110001332120300,102101211411000,110003000420200,110243234240200,110004014411012,112000120232022,102041220200010,100002320113100,112240200202201,110020321120011], + 1031321230013320: [1104100000042000,244000303210100,1342101023000230,110000011101202,1310001001103311,100114020214211], + 1402000220232130: [100001124102222,102242220202120,102122101340003,110420000002231,111324314134002,100400100022003,101300200311010,114420002322000,102321021000002,100020310010001], + 1042042022102221: [100021300101110,110201031111320,103312300110101,101403004022114,102000441132020,102024044012212,100000021030412,111001012203002,101012144004034,100141401042400], + 212022040144100: [101000021010022,100022310120003,112004031122404,114341322301120,100040234212230,102210214110002,100020204103212,100000100104142,100200024301424,100101344302232], + 200021001010022: [112324002020202,100120221021011,111242212222022,102022411100012,101401140300101,100030124210101,103220200100320,101030004004303,114000020034200,100121211012110], + 1014110004023200: [112402022014222,100220114100003,112022102003100,114202124003110,100202024031022,111200002212011,102211000230103,101101000320100,101000030304240,102242321302022], + 100012121120100: [104100012102004,110000010120043,102102011413000,100402431012022,102403404004110,102031024013013,110044020020202,102122410220401,110301311303102,110021232000021], + 100200020013000: [112012111114213,102230004030112,100100221012100,214021333002200,112102000202302,100130401022113,112001421111242,114112402340003,100341101003203,101023240314000], + 1110400243001133: [102030301440420,102120002000022,114020002300011,110201420003020,101032104004010,100011304210101,112200011102100,102001010221021,114040004102100,101000011003023], + 1023000221020120: [114102344121242,103232014032341,111432404442442,101022000320120,111140130020034,100410200433120,102302121000021,100100104032130,100032014300110,111300224132411], + 1020003132132122: [102231102020200,102120201140110,100331200141014,110112204224100,100200011002042,100113004000041,110224102230230,100120411200320,112401344040043], + 1102221301211233: [102020004022320,103220000212021,101004100323331,112212004041042,112100310203000,110212400010120,112002032340202,110140011300001,100004200020200,110003004202020], + 211104312410011: [102302214110044,103041014030230,110113122120330,102310101100011,110030010432322,110041202203140,100021404300231,101100020320003,110332242220220,101042134001001], + 1040243110000420: [112004202302034,100042001020203,102002320220202,100010044300003,111321314133000,100004410120102,101131024020440,102432101112141,102100044000000,101011211003002], + 100321110122133: [112002002000410,114100212200003,1341242223200002,103001044021102,100101141010322,100011200101123,410010230000210,1303200314211000,1000413100310100,420024220002001], + 1120020200002201: [124010311303140,111001202231001,120300040232022,132000401201221,122012440110401,202220202402001], + 120004010200102: [100102004100201,102101101140040,101012320320322,103100214001400,111230032242001,102121001343030,102324031000000,102040001130013,102102001341000,110012004422032], + 210000003211411: [101200014013241,111110202213102,114421224140413,103320400110021,102041000220322,101033244000403,100400104302144,102114001341002,112121004020022,111002024400320], + 201020442221200: [101010111002141,100120400410010,102402204020020,102132424020001,114031240044000,100022200100110,114341400001011,103003044004000,101102020333110,101041221030000], + 1020404220023402: [114020000030002,114031000022030,100201211003004,102014002000401,103103241421322,110110200001000,114121012340044,102000400240203,102104304023201,103310300140324], + 101000010240102: [114221312340014,100311204312442,100001024100241,103000020100131,101211204201231,101123001100112,111000200012220,100000110100200,100012000022100,100020034200301], + 240230023041130: [101200101021000,101430004040203,103000024014022,103122104002013,100040404102010,101020404210020,100001001021002,114200104001010,114040414014202,100000024301031], + 1040431223011021: [101202000300323,1202120201221210,110400323041022,244410001402030,100000144310420,411011320001004,144200003100020,1400102001010010,110004004413303,114131042311202], + 110021203300311: [101001040340004,101013004002011,101300011002044,112022334022101,101011324004222,103210241422022,114411312312124,103240001403000,102202204040220,102121010212140], + 1000112411110201: [102102101412200,103003000142012,1002201014202430,100112430012432,103330400114023,102403004020222,100002301031043,100040321042021,100302224314022,1211200224022400], + 122010130420230: [114040002210432,100010040122204,103314044033003,102001420220112,101422214042012], + 104303002211012: [114020200020222,100012001023042,110213022100021,114424424144210,102204321003224,111222002224302,114100104030132,100010320000004,111002024110031,110201304431033], + 130004204220341: [103001111221030,102301112004021,110000011012202,100201230412211,111010002110212,111121022221002,102000020241101,111112124402010,112312041101012,110012212130021], + 101000020023321: [102011201101012,102300304110030,114412000003141,114120430002002,103020041420212,100112011040011,114033300041020,101201220300012,100401024300321,100102030423010], + 100002340242412: [110020100042220,103443024000000,104240202023232,114030204021200,100141321000100,110022222000011,112410004012302,110202410003202,102000104014100,103000101432004], + 1022220200001400: [114210120210212], + 1042112003433210: [111304340002030,103140014002031,102224241110003,114113014000010,100043024210301,102014001130100,114321004030021,101200210302201,102422131400024,103210304000030], + 1402320014010440: [110020001310000,110214024430312,100011014100041,100310201003000,110412121110214,100212341003212,110142300120000,112013212032000,112010220224003,112001040231401], + 321001401100112: [101100230013304,102330420243012,114011024102042,114402212310021,114230200210013,101030320340141,100300004314400,110020312200022,111302222202200,101021140300031], + 1000230212300000: [112142301101040,101100000330120,101214440300301,101121100332142,100000400000241,111102214104403,100132004231230,111200122222334,102301024113440,100033230420102], + 310004202222302: [102110010210104,100040004340001,100021234303000,110420020103322,103243100130140,100030101232000,100034221043231,101140030330020,110030242131210,110142214201120], + 102141311122102: [111040120022202,102141000230040,102002400430000,101001300340322,114020204021302,101210242120124,110014342002102,102031021440000,111011022203010,100001000100020], + 103134110020202: [102114020210202,114040204014042,100001300100302,101221031020331,114301120000200,103230004030322,102102001341000,102440000200011,102100020210004,101220004012040], + 100010120022100: [100124124103003,100100221002000,102140200230020,100201220431101,110011002133011,112200402020210,101000000310110,112001000223004,112014020212002,101112041141231], + 1142222400204000: [102012001130022,110003024202043,114102222344020,101021410302022,110042104411102,103200211200414,101220120300000,101103204001012,102002000211420,110040042123002], + 101001124031043: [110304421230212,103024210102000,101322020313110,100132121023143,103022011112124,104001013140002,1001200132020010,122310321010040,110001340020010,100120110401000], + 1032131124400003: [100033000423140,110000102001204], + 1101404241110112: [111220204101421,110042120021013,112200420200200,101001010300011,114012020044224,102122401340101,110021020001220,112001024000200,110112030401012,112020012002031], + 1100024033201201: [102131104023111,100414204320344,114012012300010,100302000140001,101000004003224,100012114210011,100002314210021,114133104120204,102001340200322,102021014004211], + 120122000000000: [100304201000221,100112021020320,114212104110100,103010001422020,102300124023122,114221004100020,100002100124101,102304100210334,100403210010142,112003100241220], + 1100122114104021: [103130311444100,114102134122020,101040004010012,112214410201300,111343012200000,102201430201310,114113100210210,110413402111101,102422000200303,100000120412410], + 1100202002243010: [100021214313034,102121111023020,110000212134440,103010020012322,1341322100304120,103002020124010,1011000000040202,1300040400201021,102120010221204,102100111403011], + 121301012034141: [111001440020003,110200020010003,114121000002140,100002214100100,102120104003011,102120402000014,102000200210032,100041000100422,114020002303212,102223231121242], + 1023210031000001: [100440444301004,103304014020032,101221121020230,100232121210011,100004110000301,101310004223223,114113004120221,111210402244301,112022200234200,102100011341140], + 312014222022200: [100000020004101,110130014400011,100220040142222,110232002101410,110200021210212,110131021240303,103100101442233,100000031220100,111010000021300,114200444140203], + 1113201200402000: [110020010134221,100004020411020,100300321000010,100000421021322,112331012023100,100021010100320,101001030303000,110031210000110,100431024301030,101222321204303], + 1100202001103010: [112100124023402,101020044011003,100002414210010,102010042000041,102242204040102,102020111100200,102042411104200,102321410240300,100021014100124,100130244302034], + 122002220020300: [100024000110221,100110020031042,101301014221122,110422102110221,102102204022310,114130014001202,110010220103020,111004100022110,101002201140040,100211000412142], + 1010240142022340: [102020044000030,111202320012012,114221210003003,100003001020010,112101422301001,110040014213300,100320421002220,100120320410204,100200144320012,100021404340024], + 1120303401230212: [102403100202003,102302011000002,100140004230101,112142210422404,134402020100402,100140001004340,102140012001300,112042012001000,112040004003000,110002202000200], + 121130302020200: [100001024100241,101123001100112,111000200012220,100111124101112,100020034200301,101424011010011,100003044302003,110430034224001,101010200310212,114141212344400], + 1101010012402142: [100010400022200,102302444110110,102420221112201,101224044041002,110310004424232,100010344310042,102103214000210,100402012200112], + 1000232020203121: [101403021010233,100000011024010,110002210102120,102300431002131,110001211310124,110002204210114,114304444003432,114301002301103,111040300024441,111100220030000], + 100313042020042: [100023101042010,102112310210202,114221224002403,100013310123100,103202014031021,100101014300100,100012021032040,100400242201410,110300121301133,110420032110400], + 1410001201240030: [114220040000201,111040032200021,100404400013222,110000312201003,103042320101230,103004004001222,100311000422101,110020204421032,101402031011101,114130004101132], + 1440013030000111: [111220204101421,110042120021013,112200420200200,101001010300011,114012020044224,102122401340101,110021020001220,112001024000200,110112030401012,112020012002031], + 100301010204032: [102143124001400,100020440122040,102002034010400,102020030220401,101002121000111,112404002023002,100033134104200,114003422304142,101432024040221,111001404112102], + 124402010411222: [100034304101213,114002014100310,103044010120003,100020020121132,103311100112220,103133031440020,100110021040020,114000242303001,114020402331130,114402044140023], + 1020200330004141: [114313304002310,102004110223232,112204010411101,103202404003021,103211010211331], + 110300002203010: [110012000141104,140300020110000,100003301030120,100101004230030,103044004034040,102412140201410,114034000012210,100341231000131,102200414042021,102021112004011], + 100321002002300: [100002100100210,100400002201113,102420424042020,100010001032223,102111024000402,114321002320001,103020031403100,102200401111200,102000430221040,114003104031111], + 100310010321124: [103114001444241,102140001343104,101000004010022,102223000204140,111324002200000,101301031000000,103122340101040,102012114000000,100001214214401,101001004003040], + 110032110212121: [110444010032242,100001041031013,110300112023012,110224200113042,101000020301410,114000102210200,101041001032310,103103210111220,103100100100104,102121414000042], + 1100024401100200: [112014002002044,100421200012012,101441201011100,100032321230000,102320000212000,110122240004011,114001204104041,101240020300231,101000200312024,100001221232120], + 102002211230222: [101020204002030,114023010024000,114000204101231,100000400412200,111100232241200,100001020121021,102111024004010,103343010113030,114040202214201,100200001210240], + 121142410401003: [114220040000201,111040032200021,102241044033231,110000312201003,103004004001222,101402031011101,100311000422101,114130004101132,110123121301400,111342000010313], + 1001240402033020: [102102000213403,100140000410014,101041344000400,100020420123031,102412020234414,102202424111200,102100040220330,101002424214013,100012101022110,100400222200110], + 1101410003400203: [102334004110232,103013000104404,112200102024122,103000034003300,112300032000100,101000100322140,114010010002314,114124002341030,110302322102041,111300202200414], + 1004202203130302: [112001222000410,101044334210011,102100141123000,100222104100230,100230201002203,101200410300011,101001040320001,101441244021202,110442111340444,112001240220022], + 1121000234302040: [101011004212201,101010304000003,110032022002020,100214230430124,103031234000122,102044021101411,101100104002023,101042001021012,103230011412301,100400000010020], + 112011210121320: [102110231441040,100113214302002,102412004000132,110000002133140,101233341022410,100100124100031,114120224120140,120240000020201,102203104001001,114210134003124], + 141201003021321: [100113220020101,114031000022030,102014002000401,103103241421322,100300211000020,102104304023201,100002224244002,114310200002400,103211220100010,101202201021310], + 200241001410222: [100122420031012,102202401114113,101021001031113,100100124234311,100022004310010,100320140043202,102403320201130,100123341012403,112413022010001,100000021034001], + 1000420403122001: [102021024000010,102300010242330,102000401120420,114042014014024,100000000200102,114011102210402,102100200233123,101012421000011,114300100000041,102222014011300], + 1401140104022240: [102010202004402,111130312211003,103224041400220,101001010300404,103340004020422,102410220200004,103113010102100,101224044041002,100040400401001,100320114314042], + 1420030130044012: [100032041021210,110004301222000,102001301120112,103203401400132,103142111441040,110220410000040,101030004010034,103100104000121,100321001001010,100002111020202], + 1002201204043011: [103130000213404,100400200034310,100043001221100,100221201212000,110133421001002,114212102341020,111022112202211,114130002310330,111221402210202,100422122201040], + 1020120231221102: [101301014221122,114110200212210,102102204022310,110012130410040,100104101200201,112201010203210,102021001411110,103042320101230,110041102012100,114222010213042], + 100001001121021: [110400112011100,100321004011041,110002342100014,110241024242442,110021312002040,111101042244210,110441010002400,112220001100200,114203104001000,114302200014241], + 1030043000324201: [102303010241010,102230130203001,100001221021031,103313404030100,101400201014000,102231041120104,114031010040010,100010101020404,100011000410110,101300144220010], + 121014121114103: [100030100410121], + 104021142114400: [101221422120021,103001024002110,100001000002210,101210300302302,110100012120201,110020204200342,100000220011133,100010104312120,102144012001113,110422030400241], + 103000020420000: [102033021130021,114000332303001,111224340011202,101220004013020,102121204101001,114422104140213,114032100011421,103030140101012,114210032320241,103130001442000], + 1100000312010000: [1100440001000000,100200100321211,1042210303140101,114222442341000,120011302331200,1302421010300120,110044101320101,102432330000101,1010213000040012,1320030222200024], + 1010022000402020: [1024002314000141,1010432014422122,1000020210001012,110321200010003,1341420023200031,1341200201004020], + 1404324332034203: [103202004001120,103021024013303,1300022002310414,1112301032024000], + 102002233023024: [101112104200011,103032221421243,100120004300002,110302010102310], + 202014031200020: [100124024230030,112402334040422,110000012010111,111411200002012,113400201011402,110242004420320,110110000031430,110432042223202,114100112344003,113012100143132], + 1120010022011300: [101200011020000,100031224102002,102001024011010,103042141420430,103000021431010,114023024022000,114223224111120,114022234100400,104100100402032,114130120222102], + 203020041020004: [103030411422014,103043334040203,110403010000304,102120131401230,100140024230240,101010200320244,113130020101411,102041210224224,112200030203124,103202120102101], + 141041400002401: [110240001202102,103200004030010,101002100340212,114200012321223,112000030210340,102100020214203,102201000203202,102302001000120,102111320321320,102010002000404], + 122040010020010: [100121230031032,112000431120410,103042024040104,102304104110001,101342300314204,100013200100011,114104200220022,100021221021201,110001244204302,112130011100011], + 1040330331243020: [130000220021033,114000034010043,1040014000334201,100020110003100,101310000020110,102220000230020,410010200103023,1001024230020021,100212211003002,110420001101321], + 1143003210031304: [100100221012100,100130401022113,114112402340003,100341101003203,112420100201102,101023240314000,100100230402040,100400230022124,100243040432000], + 102200013013120: [100202440410010,4000344002004121,200001320002101,1031104420000230,1040100003200241], + 134300001000004: [100003021033300,100142010410011,102110020202330,100001010014420,102041410242244,102101220214011,114001214100103,101200004040021,102323201000412,112102314020000], + 1201110240321000: [100022102100243,241221402002000,1030200104020421,1000102021230333,110344021203140,4002244101001011,100022020402123,101212413013223,1042431100100100,100004424041022], + 1000400010410124: [102121221343020,101010101022202,112104424022201,100013211002142,102211204000440,100200001001420,114141024004011,114140044002043,111030424400000,110202221212123], + 100320212010400: [102004110223232,103202404003021,114010044120122], + 132213021001034: [112124004022322,111300210014020,100000100100200,103042141430211,114403210004014,101033214211000,114001100024243,112102100423402,110141112044000,100034244303010], + 1012103030140022: [114033120034402,100023221022210,100040221211010,102104010311220,102230022023230,101122001110433,100014200003002,110320022024110], + 142100002130210: [102340101000014,111203032220113,102140200212214,112241010203003,103010101412020,101031140301430,114400204144102,100303021003013,100220014223020,112300140200131], + 1000331102020020: [100200101000000,103110431441100,102101324130010,100011200121231,111201102224324,100102004100201,114040020021023,111230114102201,114201102342110,101400300300111], + 1012110430210413: [110010130000004,100000331040124,103022421400100,102122022000230,101011200324311,112030040242300,112400002021310,102301210243201,102100001414121,100010001022400], + 1004014110012432: [114210014110000,114312012300300,103322241400404,111101122102222,100040000123130,111101110031210,111022214113044,102304041004110,102110021120200,100003340000220], + 212220200420012: [101001040340004,101013004002011,112022334022101,101011324004222,101410401010030,103210241422022,103240001403000,102121010212140,110020124200230,100022014100321], + 1040200020402000: [114030110041300,102300001002144,102302444110110,103001000142003,110310004424232,103132424000410,112013102004422,100400220013232,110010002000100], + 122331100310204: [101013444003040,102412004000132,101420421140013,101233341022410,103013314020203,100102401010230,101030021031101,100122124100132,102400200202000,100100124100031], + 120011302134000: [101011004212201,101010304000003,110032022002020,100214230430124,103031234000122,102044021101411,101100104002023,103230011412301,101042001021012,100400000010020], + 101031003431110: [102102430310202,101020030332430,102002301410122,101010000323030,101001414212120,114200202330330,103304004023413,100022201043312,111300032204432,100000101031020], + 212101112441040: [100004221034100,100100411041000,112104034022022,100021221030421,101012114000304,102232024002401,101102120301114,101010021033011,103400014000012,101211000301100], + 120220402340022: [100304201000221,100112021020320,103010001422020,102300124023122,114221004100020,102304100210334,100403210010142,112003100241220,102204304000304,100301104104210], + 240202000220001: [101221121202421,100001020012120,100033004303220,111042022141200,112310010200312,102010101412200,101033300332204,100101004300001,110002120412130,103220221400022], + 1110232201142000: [110412001240302,100130200020214,102044001440122,102400304042142,102223314042002,410303420011020,101004204000013,102023120204401,111324104130320,111120032214004], + 130104000332042: [100111011011011,114014112300100,114030034013101,100000044204004,100002100412200,101013004001421,103000014011004,101020224210014,103200000101100,114202244101041], + 300003100022030: [142442243204131,120032010212320,1023422111011102,411001103222300,1022200104230030], + 102222013002040: [101001040340004,102424204043100,112022334022101,101011324004222,100300211000020,101410401010030,103210241422022,103240001403000,102202204040220,102121010212140], + 220102001014113: [101223024040101,102100111143220,102110021342011,103100011423301,103200014030310,110011301033002,110302232221014,101010304011100,114304312321320], + 1021220222000021: [1010130003011221,1002022200102230,1012221001334200,101010221030010,102201414042030,100000030000011], + 1031310034203010: [110033000022043,110100200030100,100000411231000,100023001222000,103140021211010,100020140121034,102340211000200,102300231000210,114000200010000,100012024210202], + 1440432020101222: [111101010010203,110110212010011,103120101441202,110011000022102,100004104210221,102202410240103,400014404414011,100000010101402,102010414013103,101201021022111], + 243412143003000: [100000111021003,102323101101400,101230330042220,1304100402114410,411242003002123,410142111403201], + 1030043000201201: [102202014030042,100000100000104,101410204001212,103102124002001,101002224003212,112033024000234,100412100430011,102210210200002,102203101300422,102021120240030], + 1101340441001211: [103141411420221,122102400312000,110002100110002,1340024302404122,113110330121030,410020013004430,1002300040412102,123211320000102,4000344002004121,1300202030404201], + 320420211024020: [110001332120300,102101211411000,110004014411012,101420021010003,100400122201222,100222110000310,100402210013013,112032040234431,110010232004000,100102210414110], + 1142002320040000: [101301014221122,114110200212210,102102204022310,114040210022000,110012130410040,100104101200201,112201010203210,103042320101230,100020300102123,100120430411222], + 134302040100010: [102121221343020,112104424022201,1302314034023041,1300034431310021,1001010233020100,112012200120020,102210104000000,111023100040110,111041134000211,102203211104211], + 211344000044232: [114202400210000,100302014210100,100043111020130,103112004004201,100122210402412,101020124210122,102002021121202,112040030223200,101011001114014,102204004030201], + 1101000101020220: [102400031401212,114013342210210,112430012022003,110141012040443,102200001300021,101000044002001,100000131232000,110200222120200,101010101140420,110203321302023], + 124200002000111: [110011000020032,111000044400210,110004204210030,102222021012222,100033304311024,112231212040100,101230004013020,101411204021211,110304122100132,101420040334122], + 1000021144320022: [114042304100001,102210224012020,114313302321311,102212300202110,100012120201211,102210304013310,112101020200032,101220000302410,100024414212001,100000220100210], + 100213121033040: [100011000202214,103040020122332,100000024100000,102200130202201,100010040001210,114302404002020,102001121132032,100001300012442,100011114300032,100022304302043], + 134020400412303: [110000412003001,102011331131302,100423201003400,114000230023300,102021204013000,112042024000020,110022100044100,114400200004310,110003000024101,102400401412102], + 1011210200303001: [112102002010103,102121111120001,110112130003104,111100002112001,100100101200012,111000044123400,110102012010400,111101104421320,101003040303000,100003000423104], + 1114140000000410: [100030401020131,100020344302010,100002100000100,114100102340003,100100414230101,110130030020000,111214004444320,114024200040021,110112001300220,111024132204021], + 4004040041142200: [110420140032102,100110014103210,102013130223020,104100302102030,110002002002112,110202120004000,100041204331000,114012032240012,110000242104040,114000444100400], + 104431031024202: [102224101113104,114202144102100,103000214012040,112012012002100,102314001000244,100034140011211,114100000031020,103242004031022,100003124211410,102333204110024], + 1430013111032021: [110001022000001,110023342101220,101001421031220,100021004310222,100001000100000,112220322030220,110202222043022,110313312021120,100220214333200,110330234422000], + 1111020410302022: [100020004313034,101400120320033,110430030000041,102020004000301,114114204001401,101042214000121,102000121102220,100014300000200,100210130430132,101031101024100], + 120202032400401: [114000044020204,103044010120003,110142020400012,100142011022211,114230344103210,100030020104423,100000001021041,101000401032212,100004104241121,101303414220001], + 114443440200440: [110010220040411,100010021002314,100022441042300,103100111424040,103020040142112,103210001410031,102304000242033,103002221400000,100010020101220,101400200303132], + 1100403120001102: [122422422004001,214021333002200], + 140110000402210: [100000400000241,111102214104403,100132004231230,102120131401230,112402002010000,110021340020022,101010001000320,101022021030201,111001014111122,101003204000300], + 112000203233200: [114222004004201,101140334001111,1012321211130014,411242003002123,103224040221400], + 103213013001022: [114004004100210,100002100124101,102204304000304,114003320044100,103040004011113,103030130100011,114034224033402,101040040300223,101124014000140,102144401410210], + 200211414412141: [114222004004201,110400323041022,101140334001111,1012321211130014,103224040221400], + 201243240130300: [120200102001400,402101003201022,1300102201211020,101313330340001], + 121010412002101: [110111111010000,112134000201310,112230122030224,114120014004003,100110130000123,100200201213011,102030000221134,100010020003310,101042204010110,100022024300010], + 1024030321304320: [114030110041300,102300001002144,103132424000410,112013102004422,100400220013232,110010002000100], + 1002414214030021: [103101200221334,114021000012310,110041001300210,100400414300130,100400231000200,110332030011233,114000210010231,101000100340001,101300240310420,101000344223010], + 230410311401320: [100020004313034,101400120320033,110430030000041,102140411342420,102020004000301,114114204001401,101042214000121,102000121102220,100014300000200,100210130430132], + 200002004323001: [102402024000034,103012024004312,102214020242110,114102224104002,101140320330114,114422404110312,102403144000120,112120020230024,103221021412001,101010010300020], + 1204300000300222: [110240001202102,101023001024400,112020002311112,101002100340212,114200012321223,112000030210340,102201000203202,102111320321320,102010002000404,100024220122100], + 1031232004022201: [110311331003000,101020240300003,112300032000100,112021334001000,100144430411240,111000024401300,102321040213311,111210442211022,101120030010320,114124002341030], + 1122133010410100: [101033011001100,114314300012000,101011010320431,100100004230402,102321401104012,103041414001042,114200022300033,100000200100141,100002004344013,103220000104122], + 201402200001143: [110213012044343,102232401114310,100320224314301,101400004022212,101020111032030,103411220132012,102020001101232,101423120303010,111102130021203,101410021010400], + 1001002024000000: [103301244010210,100101031041022,100000240003101,100041234101100,103001220100000,114124420032020,114100000031020,102401024020221,111231012242301,103240404032240], + 1000301100131100: [114330014002002,102141124004222,102430201110000,114020024104430,102010210200102,102124002000102,112002040214231,112042422001032,102100222002040,100011004312001], + 1000000201241220: [110022004410312,102000401442010,102000014004040,111020004400234,321114010100340,100121041041101,102322101000200,101020041000102,1042012320010021,110413131000201], + 1240213020110002: [101141314000221,103041000000104,110033101314000,110223034240100,101041014010212,102220232001303,110020102202100,110301120042202,101002211000243,114313010000002], + 243004100003202: [100023421041402,102120031140142,101010224000130,101144134001102,110012220002021,100210020410010,114034422302101,101000414002041,110220302043002,102322004112023], + 1202200330200101: [114011220041204,100301031002201,100000224311320,102120121212031,112022040242001,112000400223100,100211111003420,101100004022130,103123314002423,114310332300121], + 131040411001201: [102101211411000,100102224033421,100120040400011,100400110020244,102021001411110,110041102012100,114222010213042,114011120010030,102310100243242,100200044121414], + 221211100144431: [101001040340004,102424204043100,112022334022101,101011324004222,100300211000020,101410401010030,103210241422022,103240001403000,102202204040220,102121010212140], + 224102100212001: [100012134302230,102102240210112,102012110232021,103300201400340,102002230200001,102404341113402,100020000100311,101444031100130,114404214140114,102033442000014], + 1000120202102321: [111201032220400,114203000004300,100022120412132,100000321031423,110322100104010,100031314241140,114043002302200,101222121020001,102120230230000,100032021041010], + 121312320102000: [114300240002100,111010142110323,101011100301224,100400000020101,100020240000242,100002404312012,101100020320000,110034104202330,101000011030000,112122002010012], + 243102213000012: [102021401410001,114210410000401,102002410222340,103210214003143,100110000020111,114401000004202,100024104100032,102100014132110,100021304103002,101120024021024], + 103022210000212: [100310120141002,103000004002012,100002011042020,100301421002002,103022021431010,103200020111014,100010004313001,102010200221000,101041201002422,103104200210410], + 1023022214100312: [114410024110002,111200210001023,101101401020424,114030220011120,100002200100100,112002110240403,100002210000020,112410110201010,100020000120134,112422100200404], + 132202034111210: [110012031011302,111200104411001,102121200313040,111011104401124,100300021202320,111201004131300,111311434120141,110334102021144,111421020001110,111212120001103], + 1140033110031000: [102000321102310,102400234020130,102134044134410,101202001022000,111300220000230,100133204300040,114110032343001,100110101040020,114012222301110,102001024011010], + 1020023122320003: [112224111100141,101221414041100,101021244012200,100210301002021,103040000000212,103000001410123,101300004211000,111240300002140,100100040402102,103213114041040], + 200230211401001: [1010020012204013], + 210030132003021: [100442004304040,102020120201002,110001000034023,111041104111423,102130000233203,112422422020403,100014030122210,112242100412003,110220001312011,102042011413203], + 1130301021110112: [114222004004201,244410001402030,101140334001111,1043011000420133,110004004413303,103224040221400], + 1140200203022032: [100233014224240,110110200001000,102221414000020,110004210004223,102302004110231,102203004032420,110000034212000,103110400120220,110203021004214,103101100123012], + 1124003000100220: [100440031001120,114203042330220,100020001041410,102032012000101,102102231400111,114014112302234,101004201001232,112102102302000,102141231343401,100002020101023], + 1013221012420000: [102142221342202,101012400343401,100020101020404,100002411021201,101000410321210,111111102240001,102001041100103,100141431011400,100030324102411,114021004100002], + 1421100100403020: [102430201110000,102124002000102,101343331004220,100140310020221,100002131020410,114044414023030,114244014002020,114420102322024,114010120020000,112210314012010], + 102410302400213: [100024000110221,100110020031042,101301014221122,110422102110221,102102204022310,114130014001202,110010220103020,111004100022110,114040210022000,111001344400222], + 121300003210140: [1020102021344321,100104302001300,320424300313211,1001102321230101,1002001200441033,101040020314000,1101003130212010], + 100002030010010: [100000111021003,103012000142231,103000001004002,102344210242220,411242003002123], + 1014201304131122: [110431442110400,114011120021012,100100111041320,102334001004100,114110002202241,100001140411014,100002000000003,101312014234200,114000012210041,100000024214212], + 111332213032111: [114203104112214,112221002043330,103214200103130,101011024213031,112222042030004,102230200204114,114241010002120,100040001221420,110102110120200,101210021000110], + 1120222022100010: [114343002322014,100022314100104,102130314131401,114100022342130,114300010002100,100013024312024,102002020243020,114002002300201,111012002200101,102040021121030], + 1111012321012031: [102033021130021,100000121042240,114000332303001,102141100210112,114130200001000,100022224312021,114044240023401,110240221202310,102022104010020,102101122004040], + 1004401211002003: [102312440201042,101301211001210,102200000200400,110000001102024,112011004023221,112020111124021,104130442103002,100110304032200,114121304000010,102200004040001], + 1400110010240302: [102424204043100,100300211000020,103211220100010,101202201021310,103044004010022,114130020222342,112301032022414,102103100310300,102012014002001,101010231002004], + 1010043221034024: [100022314100104,102130314131401,110200002031302,102002020243020,114002002300201,102040021121030,100311314310000,100000204130001,102041130200101,102104001320022], + 220000241210412: [111010204402020,112010201112142,100101141010322,114003102303200,100000044310330,100030134100201,112000020240130,112400232022200,100103020400014,102100430314220], + 122040221404000: [103030411422014,103043334040203,110422201312402,102120131401230,110200302024000,113130020101411,102041210224224,112200030203124,102004020224404,114201024101004], + 100203010304010: [101001201110100,112010420232040,100032114202001,100001324201100,101440004041103,100220410101001,112200202021003,100004104214300,101023024210000,110000442001100], + 212222204100141: [100200400430003,114420102323300,110404122110112,110403010000304,114100040214000,101210021021243,102412044040011,100140024230240,101010200320244,102214000210013], + 1400223320112100: [100000044301222,111012034402110,114221004034110,101223041020020,100011230120014,101104024002242,110133120011001,100400010013033,110100000031102,100100001043001], + 221031204224014: [110000022003412,102401200232302,102230221100001,100112224301402,100011100102010,100022404210000,101322224220202,100003100011100,112003000230001,110002120141023], + 121003401231030: [102431111110001,102013421100201,1003002030122040,202003402402323,120204110000223,100400002201002,1110002442211200], + 1101033011410301: [114011120021012,100100111041320,102334001004100,114110002202241,100001140411014,100002000000003,101312014234200,114000012210041,112003034003102,100301020420101], + 100241101234331: [102110000210300,102422021113012,104220041321240,101021321034010,103422421110341,110001120421122,100112044302010,100300030421240,102022300202200,102010424011101], + 1102201014122203: [100040004210202,110301000400042,100220222000100,101430221010100,102130000201200,120440011014232,114230232331111,111220002220203,122330120132002,100030044101131], + 1110221100012414: [100300041001121,101240004011021,101011001103200,102022020204430,101002244012322,102302210210322,100012401020212,102000324011143,100003131040012,103004044010300], + 1000001104420100: [110130010102101,111022412140224,100212034221414,112004001122300,100222100402024,101301124222004,100121301023030,100014000022201,112204220200011,101121401110420], + 1000311211400300: [100021314202402,103142211442311,100111011040002,100041221020214,100040341021101,111123212212000,100014001030021,100230221002200,112003020230203,114224012340002], + 1100002000111104: [1043303323011400,1140104002020100,140011220320300,400040001020004,1001120000022000,101201220402420,114200022340011], + 1101221303412122: [101011004212201,110032022002020,100214230430124,103031234000122,100400110020244,101042001021012,103230011412301,101100104002023,100400000010020,100124021201021], + 1020240011302114: [100004204302330,114202144102100,103000214012040,112404120200000,114102004142411,100004400100414,100034140011211,100041244344014,100230211002042,103020221401210], + 130004024000101: [102020410220200,100013014101040,100402010420301,1130420100342202,420001430323202,111403040111110,200323000114220,140020100011012,202041211000230,210040011012132], + 1121232003300200: [101204400304011,100020440122040,112404002023002,103003004044030,114030300020401,103101030211200,102042231130200,114440020003320,103310420142020,102342301104201], + 100004200423100: [101342300314204,114013124030022,114104200220022,100021221021201,110001244204302,102010244010000,103003204011330,114430412322343,114200034110031,100000430014301], + 1104030001004442: [114300240002100,101420000304222,111010142110323,100003100201031,101011100301224,100122100000002,101213424040301,100400000020101,100020240000242,100002404312012], + 101210141320242: [100011004340114,102101101140040,102000021444112,103100214001400,100003010413400,102121001343030,102102030210111,101201041010123,112410212020002,102132210233141], + 1010331011142020: [110310304430141,110301120404342,102113304130002,102000131131100,103124420221210,100011034302423,114032024012040,114200144110020,102142002000002,102021011132142], + 1000002200023000: [110033000022043,101230004040022,101021020324310,103140021211010,100020140121034,102340211000200,114021000044211,114000200010000,101312014223102,100012024210202], + 120310000220004: [103221204032410,100004004102410,111121004103434,102112041020001,102202014042012,100221110101420,102441030231300,103032000144301,100003220100000,100131100021014], + 1140010101240441: [100023421041402,101144134001102,103002144042123,110012220002021,102304204110040,100210020410010,114034422302101,101000414002041,110421104242000,110220302043002], + 1000440004202002: [110221212111000,100102404302220,102120141142220,130024021000014,110040030000044,102144030230210,112430102422123,110001004411040,102311204033230,111000012114440], + 1024020120210001: [100023421041402,101010224000130,101144134001102,103002144042123,110012220002021,100210020410010,114034422302101,101000414002041,110421104242000,110220302043002], + 1244233110000000: [101010401111401,103000030113423,113100011041100,114121022343214,110000140110211,110200102222003,110022314201040,101443100300002,110030214201200,103012001410013], + 1100001101413002: [110221002120123,100130020020131,110012214201121,102001430222111,110220242120021,100300021003040,111422222100131,101010101122101,100001044313211,101122304002402], + 221141213310101: [110130321300301,111020104110202,102240200242002,101000411030013,114300200000110,1003110100202043,100313041004240,101322310313010,100000000410101,114403020000214], + 1411030102004202: [101042410301221,110432300102000,100011004102400,102304000210204,110040344210011,100020120101000,100003200020112,100400231000200,101000100340001,101300240310420], + 1102024004211201: [102121201340001,102200211120103,110400242110410,111302204123234,114132040223044,100030020423044,103013104002044,114211004004210,100034204310001,111202000003000], + 240121030400140: [102402124022000,100200200412034,101012114000304,102202141120400,103004041410020,110120224221100,103444024001001,101004004211001,101002000323021,103122404000344], + 1010033111224110: [100000111000003,112400104044001,114423002313230,103201021402002,101010401021030,100304101200101,114001310020023,100201130410420,112010214003000,100404220013411], + 1402042022111000: [110043132100300,110132031134031,103002124003020,114020024120310,121021032342113,433402331200202,102222034401200,110030221221100,1001412211040002,1122204031101014], + 1121000002002224: [110041240000013,110131122012210,100012044101230,111021212200430,100021214210112,112010034020230,103021004011210,103120204002200,102404121400201,101020204003012], + 1043411013220000: [103301244010210,103001220100000,112012012002100,114100000031020,100003124211410,102401024020221,111231012242301,114444004140210,114114100214000,102220210203210], + 1000212010040112: [114020000030002,114031000022030,100201211003004,102014002000401,103103241421322,110110200001000,114121012340044,102000400240203,102104304023201,103310300140324], + 110323231000020: [102300200220002,404002010120214,1001412211040002,112100424020221,103144011212002,1304032042210300,1310241403200440,1010300130110420,214301004122000,1310330201104132], + 200134144110100: [110102042010220,101020124000413,111210000001101,114013400011030,103004104010210,101220024041000,102010300201414,114330432320002,101413004041201,112224012020000], + 1132204021210003: [114104204002313,114300000002130,102122210230200,110421410100301,111020020020030,111040102231022,130102301112413,111040000020020,100101114030101,120202202001010], + 103002301000110: [114220040000201,111040032200021,100404400013222,102241044033231,112201010203210,100000214310412,110000312201003,103042320101230,103004004001222,100311000422101], + 101200200101100: [114020202300410,110430341310122,102140201343122,100400100020024,101102241114000,241220023100031,110014142204101,102001104014024,123010242104441,100203321004410], + 122122021020122: [102101021412120,110024020421011,100042014310200,100003014314102,100040224102124,102100011000033,100011214102010,102112241342203,100002004200212,110010332201012], + 112220120041433: [103000104004220,100100201043023,110243010010124,101211010300011,101100424003101,100201401010000,100241131003241,102231211302002,102124001120110,110400231311120], + 1032121014401010: [1010432014422122,110321200010003,1300102203020001,1341200201004020], + 1403002142400002: [100341101003203,100100230402040], + 1002013403010200: [102131104023111,102420130230104,103000004010400,100000004310002,101021014224121,100012114210011,111301000000031,111200304131014,103020200123211,100000340120221], + 100003241210204: [101133001104410,103304014020032,114202424001100,114113004120221,1100000411441420,101122031100000,1002203010011112,101211011012300,100010300121240,1012004033012200], + 123130103211001: [100040014331413,100213020430224,110130104401101,102040044001211,101001004001001,100220301003101,110004402010202,102130204000301,102200210202001,112402204042100], + 1142301140221020: [100131024303001,102231114040010,102100001400002,102000214011041,100010004210310,101120211100120,102200004044212,100004000413200,101210004011002,100001100421120], + 112200123000404: [101242421020211,110100112141101,111230044134200,111200020004203,114100004120120,102011311103423,100430404302321,114211022324230,102301112004021,102402204023220], + 1024102402011042: [101021120323020,100102101000203,114111200034310,100001021030011,103230040101112,100010041032043,102110234020204,102441311400421,114020214033220,112030004021010], + 124402312010110: [112040232002301,100000041041202,114230000000202,122202200013331,110100321201200,101000200310011,114012322301013,114200000001030,110004424412010,102301004110302], + 1104322200003122: [102000020223013,114040102301100,112121032014014,102310111001210,100020241043022,102100121341102,100301024310020,100130010101430,103112000210401,102113121401222], + 1024420002011313: [100000111021003,102323101101400,202003402402323,101230330042220,1304100402114410,411242003002123,410142111403201], + 330001201311020: [114033120034402,100012204340000,100040221211010,102104010311220,101000404012321,102230022023230,101122001110433,100014200003002,110320022024110,112041000221020], + 144333223223000: [114402414111240,100012134302230,102012110232021,103300201400340,102002230200001,102404341113402,100020000100311,102400204024124,101444031100130,103241134020044], + 1040010022042224: [110001332120300,102101211411000,110003000420200,110243234240200,110004014411012,112000120232022,102041220200010,100002320113100,112240200202201,110020321120011], + 130200110130012: [100231001004000,103004100100121,102234100203413,103204021411022,111023102140240,103213100102030,114013010021004,101020024001432,100012004110041,103020201412331], + 200310030002324: [114042304100001,101211240301300,102212300202110,114203134112000,102000000221441,101023230330104,103014140101101,100130124030404,101401321012030,101021121112112], + 100331023200222: [110304044431200,112122104040040,102103131122203,112120012011020,112221114014010,102132014020002,111100422210104,110134000003002,111121302103104,103314201402401], + 320001302344420: [100240324101101,114203400000000,110131214220303,110021401213103,114000010042420,100400332201021,100042021022002,101004001110002,100100004300002,102020104000240], + 1100421420010241: [110000001324024,103100314001030,101020111001331,100040301042132,101000001111200,114010040023411,102110001342011,100402120030401,102001010222103,103300024014002], + 221200014212444: [110113314221413,112004310224204,102304420211002,110403042110030,110120424221121,114112132313033,100220000432400,110001000142403,100403412200201,110110000003024], + 101003110200310: [110202000000310,110000010120043,102102011413000,102403404004110,102141410230020,110020001224021,110103111120042,114420000001301,101012410301010,112100000200031], + 1011010203002001: [120200102001400,1034004021300110,1022113221121000,102001034010113,101313330340001], + 1101111001102233: [100101011010340,111111000014001,114024312202242,100020001011422,101023321000020,114033400011210,102010221132220,103100204000400,100110411200024,114020000022214], + 1441020031401101: [100101011010340,100422040021304,111111000014001,100021320123031,100014041042003,114033400011210,100002010413410,102010221132220,103100204000400,101433010300204], + 133312222130010: [112142301101040,101100000330120,101214440300301,101121100332142,100000400000241,111102214104403,100033230420102,101412001100222,101041210311410,112402002010000], + 302211121123042: [101000130320340,112401314040311,100110020031042,110422102110221,100220124221000,111004100022110,101002201140040,103030040121410,110023202100200,100211000412142], + 1040322003203120: [114444244144110,114201004110120,114033234032101,100412114304000,103001020120202,101000410321210,101000020302400,102021014012210,112400000200011,111101400011011], + 1042012232222220: [102000402041014,102041410242244,100022010411004,114000424102300,103112011421222,102323201000412,102212434110001,114240044000100,103140031420300,112102314020000], + 122101142204240: [103004031243101,100310430440011,100404230012110,113100000101010,100010200002010,110240104402203,101142234000141,110102030000113,100102411000141,114330000010023], + 1011343021000200: [112124004022322,101201220300012,102103201320411,100100031043410,114001100024243,112020100202034,110141112044000,100034244303010,101214240300211,100120000410220], + 120023031020212: [110441234224400,114021412213020,102130020200000,103100014031411,110000300424304,100032121024110,110013122130200,111403100030130,114020204102020,103121221400012], + 1040241000130200: [100411410430220,101410011012112,110131310000224,100011030400203,112104124022321,110100022012033,100103044230022,103222330131101,111001124404020,101200100300100], + 100430412000104: [101020024212042,100041204212120,102113110210240,112423424042102,100320431000002,411200101402221,100120214230002,102440100200000,103204200103440,100210004104001], + 121211000420140: [103210140100004,100020000410221,100203001002230,102031431103242,102031100211002,102300004022200,102210004041222,101032230342010,103100400212241,101202021021011], + 1000203000040112: [110302302001423,101010101022202,110240134211002,100013211002142,110104000024100,102211204000440,100200001001420,103200314020032,111030424400000,114140044002043], + 1400001001021402: [114000024100022,101001231032003,102304200241002,100043420411130,114112244122013,112144232304210,100043041020120,102022130224432,100002334201103,100022204204040], + 102404300403301: [102401121113302,100021020124002,101320040302031,114010102300010,102000014002000,101034014011332,101203011023020,100042020102003,101010034002013,101312204221040], + 1042104130021022: [101423400300400,103140114002241,101300414221100,100024011031110,102200230211200,102142221401140,112220022044223,103113211441220,102104411412302,110222042031222], + 131231010410220: [100001000011003,100220404320423], + 220001000032124: [100020001041004,202421100022041,102100111403011,1000042010002402,1100001420031333,124000002040110,433020311213122,1321202200220200,130030004001124,100040220123030], + 203000000202310: [102121240200000,101212040303123,114024142200303,100011221032200,112401042010001,102031021133300,101130314020142,100000040101003,101422210301101,102321001000013], + 1000234010211100: [100011010414200,102002121101110,112014201121001,110000100041101,100400000010033,112334320201110,103224101400400,102000002043020,110212000003404,102130101121401], + 220024101313212: [102424204043100,112022334022101,101011324004222,101410401010030,103240001403000,102202204040220,102121010212140,100004221041210,111103212211022,112002014000112], + 1020412302200343: [100341320422234,110110132041402,100004411232040,103140240112020,112034310220200,113200210100211], + 110020200112202: [110140102142200,114341024032221,102004000201030,112020401130100,103122301212000,101000141004421,112140234024202,100140314102014,100000400412331,101014200304201], + 100212003203020: [100102244330400,110012022031041,110131020012303,110313010000002,101141010323021,111003102200031,103004304040120,110321221330204,102210004032202,101023141140010], + 200200330011102: [103321411401411,100042010200121,101000010300200,110004442003322,110400141001003,100004300100000,100400110022101,103013001223110,102002010220000,101003311141110], + 1003304300123100: [100020031000013,100024004310330,111100012111200,110410324244300,110020111210101,101001001000302,111034020021310,100110040411303,102101030311301,114121012211212], + 1000130340100220: [110113022011200,114010024033002,114334222300122,114140002204140,1111310321012011,1042411340004022], + 1003321024022130: [100240324101101,114203400000000,110131214220303,114014124030001,110021401213103,114000010042420,100400332201021,100042021022002,100100004300002,102220100211221], + 1000004122122100: [102334004110232,110002002000100,103013000104404,112200102024122,103000034003300,112300032000100,101000100322140,114010010002314,114124002341030,110302322102041], + 1011000124422204: [110200002031302,102002020243020,114002002300201,102040021121030,100311314310000,102041130200101,102130224131022,100220031001210,101010200312020,101040204210210], + 1010004110010222: [102020041440000,100231001004000,100004004231003,100200024121000,103204021411022,111023102140240,100211011001040,103030020100023,100204001000003,100020040401004], + 1411101200012311: [112142301101040,101000130320340,101100000330120,101121100332142,112401314040311,102011004013000,111200122222334,100220124221000,102301024113440,100033230420102], + 240143010100122: [114222004004201,110400323041022,1134000004202341,100000144310420,411011320001004,101140334001111,1012321211130014], + 102324020101333: [100010001043004,101033044211203,103102234003012,111200044424130,112100330410121,102000111100221,112003102000220,103102424001204,110032301041321,112113222010004], + 210002002100012: [111102104100334,114202100000010,101041424000304,111440000000202,100100304303003,100001401034130,101220200304110,110403102222001,102222334041224,110121110020020], + 210422122024211: [112241020202432,103341411403412,114100130002210,100100001013001,112401002022010,103000214012340,100004204101200,102400134001010,102001004014032,101321040311120], + 1030000221023012: [100041000411231,100010101030000,100004004100120,114204120210000,114110030002020,112002100233204,102410010201202,103303001400240,102442004024220,102032440200402], + 141210203140303: [100031220004000], + 1100243232201102: [100120221021011,111242212222022,102022411100012,100020100100300,100001210102104,101401140300101,103220200100320,101030004004303,114102404120000,114000020034200], + 104022002120022: [102040431121110,101221020040220,102212000200124,100300310140241,100103104302044,101041030320401,102141212000200,102042000222002,101203121020430,100030010102102], + 220033134011013: [110402100100230,112303010200000,110120220131103,110414322014044,114200204000020,102020014000230,102113320210012,100004204130014,101011040310000,111311022200000], + 220221300012012: [140203123020300,114010230023434,144203403221310,141000201412111,110004030120020,100332121000004,102301014204000,112040314000200,114210414000324,103122201420410], + 1030003041434000: [413240313440033,1020020141223341,1040200130322041,1030422101440422,1202120201221210,1002004000020441,104140041004101,142110112121222,120023100030211,411011042301123], + 102013000012024: [104130301242304,101001114012114,114222042332003,114020210010230,100101121010100,112304211102104,100024234202001,102022024000010,112012002000200,102102001342202], + 1041320001413040: [103102010212440,100021120412010,102002344013100,110002002200300,111200302214000], + 1040022242040202: [101240110302200,111243002222100,102022011130012,101004424213001,102011444002012,100101204303002,111242212222022,102022411100012,100020100100300,100001210102104], + 1104401142320040: [102211230244321,112121214040022,100041014210020,102401221402002,102102011342302,102140200224200,101001244010120,102200121300400,101030224004130,100004314302313], + 1020200321032102: [1043303323011400,140011220320300,114200022340011,400040001020004,214301004122000,1003033202212100,1140332400310103], + 1400233004340320: [102031001411010,101400004022210,102031021441200,102300031004340,100213310112333,101200020303202,100000411002023,102303200241200,102013224003020,103013020123142], + 1000231124314300: [110043132100300,100002004201122,110132031134031,1320303202002000,1321200010022312,110130330012140,114102134002330,140403400240000,103002124003020,100003230110201], + 110021030232201: [112000112000031,100142104100403,102123214020000,114202204113222,102022124012030,100143220410040,112024000213011,114002320022312,111000004400110], + 1012341103200122: [101011004212201,101010304000003,100214230430124,103031234000122,102044021101411,101100104002023,101042001021012,103230011412301,100102001000000,103400104003420], + 100001102201100: [100002004303100,110130010102101,111000122201420,104134121240044,100212034221414,100042004301301,100012021031014,100000201032010,100404000020000,100010210410420], + 110410101201021: [102011121131022,111320010000021,100010214101101,102010202002040,102131300232014,110231202044211,103022001220121,110013122103220,112214100423320,100000320004100], + 1244120440030013: [104130242103012,100034304101213,114002014100310,102000101132400,112023140212112,102101031412121,100020020121132,103311100112220,102102010220401,100021120201020], + 114321004123230: [100020211001002,112012000223204,100000121220100,110011222202100,100201424220320,100010024302421,101022400302010,102020110221414,110000140111000,111012000002211], + 1201000040032120: [110400124241011,112104034022022,114233300214304,111020204112021,112010012000201,103022444011022,102101101021304,110210000000040,100031324100010,100024204204210], + 1100001200400334: [110040112132130,102221041100201,100204004121023,110111111010000,100413304100413,112134000201310,101002401110142,100110130000123,100200201213011,102030000221134], + 101220431440310: [103114204002100,114230004110101,100001101033010,102142002000030,100000201022420,114000024101202,100100014302013,101204031024110,112020021120403,102020204010341], + 1020032020112404: [1014410101001020,1002001101203410,102403114020212,1302014202432324,124112001101111,123140301003111], + 112230132330411: [100000004102121,101141104004013,102303000241200,111120032212032,100002210100000,103242024032020,112012000220000,102331410242212,100220020410020,103200134030201], + 121212010030101: [102100420231433,103114001444241,100020214240402,111324002200000,100030211020221,102013110232000,110014032200004,103122340101040,100001214214401,112140422012414], + 1032022200020121: [103244320114100,100032011000241,102311011000014,101010300300110,112031121113040], + 1041203000040200: [114422004110130,102012030213014,102003320200411,102002024000132,114021114023402,100401001011010,100210004343102,110100331003020,102021221120401,114242312322020], + 1002002020230401: [100200101000000,103110431441100,102100441341013,100011200121231,111201102224324,114040020021023,111230114102201,114201102342110,101400300300111,114430204112100], + 101202101400102: [100023101042010,102112310210202,114221224002403,100013310123100,100101014300100,100400242201410,110300121301133,110420032110400,102001130224032,110000220431010], + 314012200200400: [101213114040141,102210101002412,111140100011101,103220120212134,111103314101000,100012011022000,114140104122430,101100010302233,102021241324040,102100402004002], + 1002200221040000: [110202012100020,110013202003320,101031241000010,102120231343224,111342020011220,110030332100203,100314114322101,114404232310120,103100034001310,114002202210331], + 124040340101403: [102104201320013,114220104000102,114310214033042,102014001441210,111010144124143,110401200100202,102141012001120,112014014000132,103011414001001,1140000003002130], + 103140000422000: [100222004320102,100110004103122,103020200141000,102414034040100,100022304302043,103031300144042,100000111034100,103132114002002,100412200002013,114312004002020], + 110200002133204: [102310324112030,100410130030232,103220101421001,121110020100002,100002104204000,140004230143221,144200400000000,103321202010002,101124344200400,102021220202100], + 1003000020114431: [100400002201113,112024212301420,102420424042020,100240134323001,102111024000402,114321002320001,102001011100100,114402104142102,103312241402001,102122412001012], + 121210210121243: [110001332120300,110003000420200,110243234240200,110004014411012,112000120232022,102041220200010,100002320113100,112240200202201,110020321120011,102130000312121], + 1140302320420033: [101400101012223,110022010021111,102034021103200,101413304040000,100124421200122,110004301312421,110113212042223,103423040130000,100201331000141,103400004001122], + 1121402101112210: [101214200300004,114330120000222,100200241001404,110001440004103,110010022202202,100011210411120,1000301003020410,110400302222204,1014111023013000,110320044420300], + 130200211100201: [101002240304011,100201134100140,110034100040021,110213002132000,103010000110210,100311221002322,102022201020004,112102204024002,100100424030003,101000131030120], + 1122000101112244: [110400022010030,100214121000000,100042034200032,102011041100210,114323000000130,101400240300010,110202204213200,110002131200133,102412241111002,100424104302020], + 1124121012000023: [1020110422203030,112002010100420], + 1011001242142102: [110042220002210,110410200100200,102113340210000,110011401011100,102221200204022,103021030102410,101010200321421,114100212211004,112001402002232,102241021112220], + 1100011330444010: [102412004000132,101233341022410,103013314020203,110120211001001,100300400142001,100000120121031,114211324100004,101212311020000,102002000222021,110201030143012], + 134212304203011: [102220300000443,110210103122411,1300102203020001,1200020030443142], + 111100420422001: [102311024114010,100000324202120,101010404221002,103300141402002,100020400123300,103202421400110,100010431020224,114102224122040,100100401004110,100322234212034], + 1001211101340210: [114313304002310,114000302331201,112204010411101], + 1020022441200000: [100223214121011,100202221212300,110004022000404,103020210101200,110010012102144,101020200301303,112000111120040,100402300022230,112030012300122,112203414012111], + 110242040002402: [110311200403410,110200201311102,110000200420204,110332000400401,100101220411134,110011120132000,101012340321223,101002034212140,103242010130000,100020011230014], + 230444140123021: [110001332120300,102101211411000,110003000420200,110243234240200,110004014411012,112000120232022,102041220200010,100002320113100,112240200202201,110020321120011], + 1002001320444001: [112314301103022,102000222003200,110112211000311,103100001440000,112010402302400,112040400213330,100100404232002,111000122144002,103010141244132,101032301032001], + 213204132001020: [101022011003022,100003101003001,100020244100302,103140114002241,100102000423142,102000301100100,101300414221100,114020210020424,102200230211200,114001042203020], + 1400202202100022: [100321004011041,110002342100014,110021312002040,111101042244210,110441010002400,110124002040002,110023410122402,114203104001000,114302200014241,104132420010010], + 1002021222000041: [101022004224424,100201200000444,102000124012341,102020044001200,103000101431000,102011412002000,101030424210000,101200120302104,100041020121003,101002210300210], + 131110011002040: [101010001003010,110203112030000,100013020003100,110010034202123,101001334211011,100100310403103,112200010410210,110442004241010,111230112220110,100101101200411], + 1000021001013202: [102100044001000,100002134303110,110041214411012,101000300301420,101000101022043,114420240001400,110032124211302,112400122020014,110211122020222,100222000000120], + 1011200220330001: [111330120000213,101021014224121,100200021001113,111222004100001,102110010202221,103144001420031,103101130124033,102001010211020,100220114121101,114301014001424], + 231201004140100: [100040031020241,100411400030100,102120221120200,114002010040032,100400012201120,110311011330111,102020022000021,102310001100113,102000114010020,102102000312101], + 133114020011120: [110400112011100,102300120242120,110444010032242,112220001100200,114014130041210,100001041031013,114000004102022,102430001113001,114212102310100,110224200113042], + 1122410030000111: [101010001003010,110203112030000,100013020003100,100121001204222,112200010410210,111230112220110,112130400202001,102200000232102,103420021202012,103000034040212], + 332230002120240: [102123220230210,101110004021320,102201230200104,103012101401220,103001334010240,100214324104012,101333201002122,103200021404423,102013010220212,114041022210220], + 131140414102102: [112012002303014,100004340004131,100200411000410,102003101130231,102240200214023,111021220021002,101023011142204,102221014033000,110210320002400,100131104033004], + 200000022111034: [110012031011302,111011104401124,102224202023120,103000001410302,110421000003000,114200412322323,103410414000011,103440004000101,100432001014222,100212321001100], + 1144002103200220: [101020024212042,100041204212120,102113110210240,112423424042102,100320431000002,411200101402221,100120214230002,103204200103440,100210004104001,101410201111300], + 1000121202010020: [102323304112342,110240020100212,114221002340120,110021002130201,102201104020200,112202020413011,100120231204012,102324004112400,103002011422011,102201411002430], + 1020210002123402: [110100111221242,132344004001203,114303202300104,114020202201002,102100300233312,111021044400403,101231020300003,102203210201342,111001320002031,102201100232200], + 124041330110002: [104134121240044,100011004102400,100003200020112,101000100340001,101300240310420,102100020214203,103000300124010,102302001000120,114211410004214,100004120101032], + 142101043120024: [110102042010220,101020124000413,111210000001101,114013400011030,101020111030400,103004104010210,101220024041000,102010300201414,100202200003011,114330432320002], + 113034430121112: [110001332120300,110003000420200,110243234240200,110004014411012,112000120232022,102041220200010,100002320113100,112240200202201,110020321120011,102130000312121], + 100010333333320: [103101224000011,102200042000104,103002000104400,110114021000012,103002144042123,102304204110040,112020004002110,114242210004001,110031404200110,114033020020202], + 1114020200022003: [100023101042010,102112310210202,102330010243440,114042044100403,114221224002403,100013310123100,100022410101442,100024101022010,110212424242341,100101014300100], + 1100000100440321: [103324024030212,112004001122300,100222100402024,101301124222004,100014000022201,110013202120001,100124124103003,100100221002000,100230040410200,103140221211001], + 1044204133200103: [101024001034211,111122004101222,114000222213021,114102330210021,102103214000210,111001100020413,112203101100310,111301204111233], + 1120444010220201: [101010001003010,102000000200302,110010034202123,101001334211011,100100310403103,112200010410210,110442004241010,101400304022340,101232140302001,110020302131112], + 130033021300300: [110414402020021,101000034000220,114312012300300,101012104210042,101430001010032,112402012020000,103322241400404,103210120100143,101010024213100,100040000123130], + 1244110301001002: [101220224012410,103200041200112,112012111114213,100111420112041,110332221302120,114102222310100,100400230022124], + 120012002101010: [110043132100300,1321200010022312,140403400240000,103002124003020,114020024120310,121021032342113,433402331200202,102222034401200,110030221221100,1330044041003024], + 1104140214212433: [100324140141402,103204301402123,110022002120332,111110230014001,110102111204210,100301101000021,110020140044140,102131421000411,101412030302001,100000401041022], + 313032213002001: [101410411010012,100203011000010,102221104042021,100140001011002,1340010113012333,101201200300020,100000024103201,114201003002000,100100221223042,101000401120424], + 224200210414020: [114114414001404,101110144024221,100400042200210,101201404044022], + 100013001000123: [103202004001120,103021024013303,1300022002310414,1112301032024000], + 132400000020000: [102140014002141,104231322021221,101104301103200,114222404114003,100004004101010,102002204000124,114332040002242,110031000022012,103333030110111,101041330302002], + 1010224142000101: [110203131211112,110021100023210,103122000100403,102023120241131,114103412201420,110014300041302,110020041310021,114241000002004,110020310022021,110321001330010], + 212030100102001: [114200212322001,100401210020002,112210322040121,100402042200000,100010111022102,102000224000000,100002104302110,110030222130000,101022440300020,101402010301000], + 132344204303200: [100010001022313,101110014000021,111201144424102,100201040431010,101000121142221,114002232304142,110020220014012,110430031313103,110241211110014,114341104031330], + 1131320100222041: [110004020020022,100043010120010,100123044300022,102143432000102,101031001004201,102040010200101,102200434012013,112000301122111,100021301302122,114001110033210], + 134200121020120: [120004030002401,114303212321010,102104240200102,100013200001300,111241012204330,113030302200300,114210010004204], + 1040042003002100: [102100420231433,103114001444241,101000004010022,100020214240402,111324002200000,100030211020221,102013110232000,110014032200004,103122340101040,102012114000000], + 102000142013023: [100041000411231,100013014102414,101004204210100,102011001320032,111221224100202,102140040210040,100034134300203,114202000000000,114312012320120,102402220201304], + 310002023102023: [100030010011002,101021301022041,1043303323011400,100402300013130,1001120000022000,400040001020004,114200022340011,101201220402420], + 1123000000012023: [114002002300004,110100201140241,102020111324200,100042204102400,101044400300030,101024024002120,111304442220340,110203002102023,103442121212103,110032001122110], + 111012000410000: [112100124023402,101020044011003,100002414210010,100021014100124,100122040012210,101020104000001,103013200120113,101040000300110,110042141214302,100142221042020], + 1120110140012111: [102341411000203,103010210100220,101121000330012,102412000200222,110200402121400,100024001220012,101400010300020,101121101104211,102400000230200,101200011022022], + 1001000102000000: [102020410220200,140240400200310,100402010420301,102022110202024,102010140220011,1002102003210222,1130420100342202,102120000210110,111403040111110,412011223000140], + 100130014420214: [103130424000200,114010204012441,114000240030002,103244034020020,103201034020234,114013402304000,114043342241044,102240101123140,112002122000310,111020200020110], + 1020111110200021: [104110021244203,102224101113104,102103022002001,100142431013000,101000031001011,101010130321200,114202144102100,102102401412242,103000214012040,100040310123023], + 200021003221032: [102011114002011,111100132241003,114101042202201,102144201402040,100100011041201,110000214214420,114021212301131,110222410000021,114404014142133,112010112000311], + 1011300024420011: [101222101202341,110301442021010,100010024302100,100000011020412,112041000220020,102022400210202,102003034011323,111304202202230,111300000001323,110000002001040], + 202201121032030: [114011114123044,114040204014042,111230032242001,101221031020331,102101404000000,103230004030322,102300200221021,101021014000200,114100012204104,102440000200011], + 1000001010000030: [103142211442311,100111011040002,100302000140222,100041221020214,101311111000100,100040341021101,111123212212000,102400220203010,101200221011402,100014001030021], + 1010203100304300: [114201204111222,102004204041000,100104341010424,100012004101221,100004004102410,102301101004100,110432112111103,101104001101000,101000100342143,101012111001103], + 1431001312300230: [111121004103434,111121024400002,112202020200200,101304004232410,101330104221320,110143012013241,102343044111203,101220141202202,110040022120224,1000240001120303], + 120020330030101: [103020001400040,114004020010203,102014001441210,100203030110000,102141012001120,100043004200100,114001020040104,100003000100104,102120211022402,102002421413441], + 1021130040003240: [114033120034402,100023221022210,100012204340000,100040221211010,102104010311220,102230022023230,101122001110433,100014200003002,110320022024110], + 1141000301432241: [103130021444021,102100104002224,102100224000210,102031001411010,101400004022210,102031021441200,102300031004340,100213310112333,100000111022002,101200020303202], + 1110200132213102: [101240220300022,100022000410041,103020000102011,103001031420203,102301324112020,114021004100210,101040421033204,103130011441212,102100001400000,101221101000010], + 101020000040100: [101222101202341,100020220410142,120202201010210,100010024302100,100000011020412,102022400210202,102003034011323,100003341032400,103211031422023,220202121014102], + 110213020022101: [100020000410221,102031431103242,102120411343120,102300004022200,102210004041222,103210104021310,103001040142100,103022140121213,100022324200100,110311332020021], + 110022231202142: [114101404004011,100004414100021,100102404100430,103020241402220,102023110212012,114140004123401,100004340100020,100002141021000,103000421420202,102201010200001], + 1123201240400233: [102133404134022,130000220021033,1120023242400240,131114110030130,113000343131000,410120000124111,431000021231320,413200300004130,100103222310200,1322000200210101], + 1143000002101030: [110000121222112,103102124000402,102221044031031,112410112010214,102201011123104,114022004100430,102300000242022,112204022021221,102000010202034,101030311000240], + 1102200234121403: [102420101111121,102101244022242,101041020321002,114101042313041,122112024242100,121211001014412,111012222200402,103300221402010,114021004010042,102112210200401], + 1000000112003432: [111223402220443,102002040220110,110430000400002,111121102240240,111320022200100,100300001002041,102232004040004,103000200122014,102203001120342,103133004002010], + 1103213302420010: [110202012100020,102303010241010,102120231343224,111342020011220,100314114322101,102230130203001,103100034001310,102021401324232,111222102243400,101004410311232], + 101001020021044: [111323002200100,100021044202120,100442004304040,103102420121202,102020120201002,110001000034023,111041104111423,102130000233203,100014030122210,110220001312011], + 1022103011020341: [101210010304011,103120400210000,114144004124200,110011424414202,110234012243001,110000214202000,100040011023003,100123031023104,114223212320410,101004020312432], + 244120003220123: [114101024120020,102004011440212,103140320213200,100000001021013,100011204300012,114003134011032,100101234330123,110024000432310,102012101443110,110032220022103], + 220100001004033: [100000200202012,111102110012000,111142010020301,100031201030331,112114324040000,100141011011032,100010021034000,103132004002020,101000344010212,102001204001021], + 1220401442000121: [111120230020122,114301000000002,112124310203104,100113324103000,102001000221124,102023021321020,114040204014042,100040401020413,112414334044310,114001010044120], + 200311104203320: [100223214121011,112024121130304,100202221212300,110004022000404,103020210101200,110010012102144,100413124100101,101020200301303,112000111120040,100402300022230], + 1021042002000303: [102040431121110,114111100021420,112024212301420,102212000200124,100300310140241,100240134323001,102141212000200,102042000222002,102001011100100,114402104142102], + 202304322304203: [101020204002030,114031212300211,102013110201200,103102211440104,102111022001024,103210431422030,111101100021200,114023010024000,102042321440100,114000204101231], + 1022102003220420: [102014000220330,101111120013000,111000042230334,112000041121113,100100014032320,111240114103014,101002011030014,114400234121111,100222000000141,101020314000000], + 100230030301010: [103000001432331,110131110401120,103000004011102,100120041014034,112111110422120,102130300200301,100121100002240,100001004340202,101104220322100,100001001201301], + 110100301222421: [110330400010040,100101231004020,111000100012002,111102010012102,111300030012334,100143040411011,102404404004104,114002202302000,100034000000002,100400100031022], + 1034240421010020: [100001044201401,103022120100401,112411042012210,100110444302011,102142140210001,102000202041211,100211004220330,100000304104221,101002104004003,114124004001310], + 1120032002001300: [101120204002140,100000020421013,101020024002022,110120011002420,100100224230014,112002112002220,110012404411012,100012304300004,102340411101202,101011421140423], + 123000001311020: [114021132202032,112012004004324,103001314001021,114122220031004,103040024041111,101004004213014,111124002211203,114022214031210,114013000041000,100010111040104], + 113310300003030: [110104112010103,111102004100101,100122004300410,102202414041044,102140014001101,102000104012232,102021100220101,114443330001442,100230120001003,112042110220004], + 222002101012111: [102121240200000,101212040303123,100001100013110,114024142200303,101204444040122,100011221032200,112401042010001,103223200110112,102031021133300,100011301043341], + 1021243020111223: [103400100131022,101004141000312,100010014313003,114100212210001,100022230100202,110100020004310,114143200211211,112120404000342,110112022120231,110402101344233], + 1022323012220104: [103302111402002,114304104031224,114223100000020,103143000120100,114100212201200,103001010120120,103024011421302,101022240322210,102111001142102,114042000022020], + 220404000010010: [102010200221000,101041201002422,112000002000420,114201224110141,112431004013030,114144100031004,114420022314022,102322001000202,101040010321004,112133112013220], + 130424021410431: [100002014200331,102012004000003,100411000030110,102041201121230,103011014042120,101012204221200,100300114310112,110002222134011,103031301400034,112400322020220], + 1110222031312002: [102131104023111,103000004010400,100302000140001,100000004310002,101000004003224,100012114210011,100000340120221,114133104120204,102001340200322,102021014004211], + 314040100230022: [110220100000102,114042102330002,102102011414242,100041004100221,100014001041000,102310030240210,110000010033022,102210000201040,110110122210000,102200400234000], + 140320003000212: [100141220000211,110042202002303,103102010212440,100021120412010,110002002200300,102002344013100,111200302214000,110443002010003], + 102102130320411: [110043132100300,110132031134031,1321200010022312,114102134002330,140403400240000,100003230110201,103002124003020,114020024120310,424022002302000,433402331200202], + 221000031130012: [111021400042001,110421420000201,110310000104014,111042430000132,103204301200000,103010311410024,101100311144441,114041022300110,102230002023220,120120411222000], + 1002201042000122: [100111211021233,114002002300004,110100201140241,100203210003004,102020111324200,100042204102400,101044400300030,112120124020214,111304442220340,110203002102023], + 1422314320100012: [100222004320102,100110004103122,102200130202201,103020200141000,102414034040100,100000111034100,103132114002002,100412200002013,103320311401000,102133001404002], + 100222000400201: [100422321032021,1320124301012211,1004001130000222,411311131413022,1110002442211200], + 111132320230042: [110202012100020,110013202003320,101031241000010,102120231343224,111342020011220,110030332100203,100314114322101,114404232310120,103100034001310,114002202210331], + 1040204040144003: [103242420100012,110002320424340,103130311444100,101040004010012,100100210000011,102200000200201,110020402004210,102120124004021,114004030023211,111343012200000], + 1134113000102000: [112030022000210,114002102301240,114002000021020,110200440403400,110000000040230,102334004031222,114010214011010,101102104021011,110000011300101,101433111100002], + 203002210300011: [114002200000421,111210044101201,101020321002002,111123014100000,110011020002013,100104004301000,112031121123424,112010000240000,100010001232233,100021024100103], + 1100002021041012: [114101024120020,102004011440212,103140320213200,100000001021013,100011204300012,114003134011032,100101234330123,110024000432310,102012101443110,110032220022103], + 1044311200002340: [101011411020120,101000010201420,1320010021102402,201200032021040,100040011432042,401000020221031,100201001100200,1440003320032101,102104410220023,1440100023013130], + 1100100330040101: [101233330041031,100013104102120,100002300012411,110412221244140,112220020202300,111200012201041,101102041114021,1022201020410210,112003414002222,110200241201421], + 100000002020020: [102101000233100,112100420203042,100311021003200,100004011233001,112001002002210,103024004040130,101412320300200,100121210401010,101104200334011,110004302201340], + 1122001010110201: [100100001041204,100002001024002,114002100040223,102430001400101,114032300044004,103210140100004,114021404100022,111030004402002,103012044010020,424403102314310], + 122230122010403: [102312441104020,100013411224200,110012442200211,103101201241421,110003302000022,100210101003122,102231011100310,111121314402323,100030024302210,101012220320240], + 1011002004440020: [102102000213403,102334000243030,100140000410014,101041344000400,100020420123031,102412020234414,102202424111200,102100040220330,101002424214013,114102002201042], + 203403011233203: [101203102121344,114001024011334,102142002031221,102312144114200,101420211014000,100001214100201,120012102310332,101022220320012,103023404040213,101302224231010], + 102121312430220: [122422422004001,214021333002200], + 1000243001203320: [112121212300101,101401300300011,100032001041230,100141120014242,102204044042410,113000201000000,100142114304120,103031014003010,101001021032110,114400404121002], + 102130000101141: [101230111024130,1112100200412130,1320100232411004,100121120102303,114100222340120,132011000122003,120100010104132,110230010002303,103002020001300,423203002400042], + 1030104001111122: [100301224310100,103002104012101,103220130211414,100012324202240,110003410100312,114000022300301,114000000021100,142100040004101,122040240311100,114302030001000], + 130002130204300: [111102214104403,103043334040203,102120131401230,110200302024000,110021340020022,101010001000320,110210020104031,113130020101411,102041210224224,100130334030100], + 213430212300013: [102104410220023,1024002314000141,1010432014422122,110321200010003,1341420023200031,103220020131102], + 213010300002202: [103111001422000,111244302220204,100042100102211,100300041001121,102110030200120,101114000332010,112112211102024,114001032300011,100142044103021,101100010012423], + 1443140010001120: [101001040340004,112022334022101,101011324004222,100300211000020,101410401010030,103210241422022,103240001403000,102121010212140,110020124200230,100042034202031], + 243044013003000: [103211311412021,102122410310113], + 100002120040020: [100030131042200,101203004042010,114221000210214,101410044041001,111104224102244,102422214021111,103400004000422,110020104210120,103130201421040,110040302100103], + 102313021200401: [101301014221122,114220040000201,102102204022310,114040210022000,100404400013222,112201010203210,100000214310412,103042320101230,100131204234041,100020300102123], + 1002022312000340: [100024000110221,114130014001202,110010220103020,111004100022110,114040210022000,111001344400222,101021204010011,100141021004020,103012101410102,111000000000411], + 1400040021022004: [110104112010103,111102004100101,100122004300410,102202414041044,102140014001101,102000104012232,102021100220101,114443330001442,100230120001003,112042110220004], + 240020422030110: [102010244010000,114430412322343,100000430014301,114010134021022,100040240003341,114102224104002,114422404110312,112140134003231,110102211300112,102403144000120], + 101010010004203: [110111032140220,100023101042010,102112310210202,102330010243440,111011002200232,114042044100403,114221224002403,100013310123100,100022410101442,100024101022010], + 1202304214213304: [101011004212201,101010304000003,110032022002020,100214230430124,103031234000122,101042001021012,103230011412301,101100104002023,100400000010020,100124021201021], + 1041001103144004: [103000001004002,103012000142231,102344210242220,110102021011203], + 1000222201130231: [1020102021344321,101030301001232,100104302001300,1001102321230101,1002001200441033,101040020314000,121000110000222,400014401213001,111200102220400,110030012002400], + 1031000201002311: [100023341032000,110121001321020,101000214010022,104230032202131,111112402101001,131120400002024,101001024040001,100220210000034,111203444130002,101202110304201], + 1133310232111130: [100304201000221,100112021020320,103010001422020,102300124023122,114221004100020,100002100124101,102304100210334,100403210010142,112003100241220,102204304000304], + 1012103333240314: [100011224100020,101124000303020,114042014104222,114444024140421,100043030100020,103010011434004,100122000100030,111112014100400,114020214033220,101201210301002], + 1001241000100430: [102242201000222,103000004011102,101410044020102,101000011032120,114004202210130,100004210412101,102102042002001,102110444130000,101420031011004,102111001341321], + 122200302004111: [112142301101040,101000130320340,101121100332142,112401314040311,100110020031042,102011004013000,111200122222334,100220124221000,102301024113440,111110004402021], + 113042102002001: [110004020020022,100043010120010,100123044300022,102143432000102,102040010200101,102200434012013,112000301122111,100021301302122,114001110033210,102013120200110], + 333000120320001: [101220112203201,100223421002014,100121004100012,112104024020004,134113234320032,102000024012122,114020420021403,101013000301230,111014034121410,102213244002203], + 1434001044302210: [100000200202012,111102110012000,111142010020301,100031201030331,100141011011032,100010021034000,103132004002020,101000344010212,102001204001021,102100431342023], + 1110244302111422: [102334004110232,110002002000100,103013000104404,112200102024122,103000034003300,112300032000100,101000100322140,114010010002314,114124002341030,110302322102041], + 1004421022143112: [103114001441122,114211110023303,111000302230100,103001101422012,100022204104123,1400100000042343,1002411322210040,110000302200313,1242324243022012,102133001120002], + 120002011243400: [100020201020032,103001010101001,111020142144200,102020001021010,111300022201241,110020001210102,110000020043321,101420200304000,100221111000020,114024102212214], + 1021014304221201: [100400002201113,102420424042020,100010001032223,102111024000402,114321002320001,102001011100100,114402104142102,102122412001012,102311120222404,114020404020132], + 104011033121030: [101041210311410,102104101122100,102423114022101,112002010221020,100034141030202,112000011111003,100100011223002,100110440112020,114002002244000,103004044040214], + 132203230000022: [112100124023402,101020044011003,100002414210010,100130244302034,100122040012210,102003100222211,103013200120113,101040000300110,110042141214302,103220041400020], + 322102004233340: [114021000012310,110432300102000,100011004102400,110040344210011,103200004030010,100003200020112,100400414300130,100400231000200,110332030011233,114000210010231], + 1000300404124000: [101012104001020,101210120302002,100140004230101,102000304001202,100010300121000,101233100300011,100001314100400,112101201102130,112342222022401,100140001004340], + 1102410232021002: [102101021412120,110024020421011,100042014310200,100003014314102,100040224102124,102100011000033,100011214102010,102112241342203,100002004200212,110010332201012], + 1102432013042000: [102101324130010,100102004100201,101400300300111,102114020210202,101200200302210,102434211400021,100001104214100,100003000412141,102000032043210,102101030214402], + 1022400332232003: [103000104004220,101002244004011,101442024042013,111020114400020,101010340331320,103031100142002,102231211302002,110000040420100,100241131003241,100201401010000], + 1003031422420202: [101012131000024,102110141410402,101044001032114,114221104114000,100001111032112,100400212200322,101140320330114,112400004020421,103221021412001], + 1002012002120220: [110010030440201,100004204302330,110020004414024,101400134043222,114340312301134,114310242320310,101100001102230,102110021401100,103102044031002,112404120200000], + 210000000011000: [100021324100000,102012220241003,101430211012120,100204021000012,103302140112020,100111044300101,114100220002002,102120401022130,101001020331204,112040200240030], + 132110000003001: [110034012104202,103042420143020,102300444113103,102304314110202,110210400002012,113032012204012,100204311000400,102011001002000,102012000241430,112002111121013], + 102000032403004: [112201102030120,114000010040241,100013104203010,103002014001010,100120434100042,114110104000022,100200404221142,102002304011000,103341121403022,100221000410001], + 100200001021000: [300302423311042,103213202221202,1021020004300440,1200300001400200], + 214001034124033: [114040102210432,100031120101224,114122220031004,112040200233002,102113111343110,103234100101221,100010111040104,103103311424020,1132202011200221,101030010320024], + 1100220411003121: [100113220020101,114031000022030,102014002000401,103103241421322,100300211000020,102104304023201,103310300140324,100002224244002,114310200002400,103211220100010], + 101410100240021: [101110014000021,114122202343044,100201040431010,100131144000002,100000100421200,103021000000411,112413000204310,100010131211222,114002232304142,110430031313103], + 1001020002040433: [102002014000220,102410004024030,114402320000202,112000002000420,102012401001012,112431004013030,114112000004001,114003002301122,100110210033043,100100000022002], + 1413030220103414: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,103022110142241,103012000100422,102023211411003], + 1122202000100101: [103100024002220,103303000112122,114003100020203,100112101024230,102231301122300,100032021000400,102010124001401,103301124014001,102001004000100,103030111240321], + 1041002302320124: [110320202023400,111431110000042,100302141003012,102004441124110,103303201400021,114101420030202,114421242204443,100000301221024,101224322120022,110104422010121], + 1141231120010103: [111314044130000,100410100030211,102000001410411,102320241001011,114102210002021,102013300200042,101001030303020,102004030201320,100020310101012,102113301342231], + 120220034001020: [1334101401030120,300302423311042,102102001411020,1021020004300440,410430103222334], + 1000002032002021: [100004221034100,100200200412034,101012114000304,102232024002401,101102120301114,102202141120400,103400014000012,101000004001310,110120224221100,110000041322002], + 1030240011000003: [100310120141002,102000402041014,103022021431010,100010004313001,102041410242244,102101220214011,100121031014040,100022010411004,114000424102300,103112011421222], + 122122000040340: [103020041420212,110100120400020,114030000030012,103000011403101,100000010202201,100111404302321,103243014020301,100012024210210,102001312042230,112020021120403], + 103202103012211: [100024000110221,101301014221122,114110200212210,102102204022310,114130014001202,110010220103020,111004100022110,114040210022000,100404400013222,111001344400222], + 1100110000012030: [102001444000222,110020004414024,101400134043222,100010400013202,114340312301134,100031220121003,114310242320310,102110021401100,100113201011032,102230000204000], + 1400404312200102: [101100000330120,101214440300301,100000400000241,111102214104403,100132004231230,100033230420102,100000030000001,100222024100230,101412001100222,112000042000001], + 103000100000433: [110102042010220,101020124000413,111210000001101,114013400011030,102202000201220,101020111030400,103004104010210,101220024041000,102010300201414,100202200003011], + 122231000001230: [112124004022322,111300210014020,114011114123044,102103201320411,100100031043410,103042141430211,114403210004014,101033214211000,114001100024243,102101404000000], + 101100101300100: [100024000110221,101301014221122,114220040000201,102102204022310,114130014001202,110010220103020,111004100022110,114040210022000,100404400013222,111001344400222], + 1140110100121400: [114001232300102,100004004100100,102440020200100,100020211044012,102300411004200,101042044001021,100002001022030,100120101042203,101004201003132,114422204140040], + 220000401000020: [101301014221122,114220040000201,102102204022310,111040032200021,114040210022000,100404400013222,112201010203210,100000214310412,100131204234041,103042320101230], + 1004400003101421: [102340221000300,101000130320340,112401314040311,100110020031042,102011004013000,110422102110221,100220124221000,100402002201002,111110004402021,101011014002032], + 131301044100100: [102000324040000,110222200103041,112411400202001,110000110022002,140143400110002,102042211100202,102010000200240,114000002302204,112431244044400,100400312201022], + 200101204130021: [101020204002030,103100030100010,114034220041220,114000204101231,100042000102010,102013000202010,114040202214201,100200001210240,103200234030122,101040224003400], + 302002040322130: [102230121123030,103000000104034,100122204301140,102033200222311,111100004100400,102014000220344,112310032020303,100020014100010,102021224002101,114230304101022], + 122411122042220: [100024000110221,101301014221122,114110200212210,102102204022310,110010220103020,114040210022000,100404400013222,111001344400222,110012130410040,100104101200201], + 1040321410140101: [101100000330120,100000400000241,100200400430003,110212022133311,101412001100222,101041210311410,110022004211030,101210021021243,100140024230240,112230240412241], + 1020240111102100: [101021134011012,104120130021200,112421004012141,102011104010201,111100220022101,100021104201130,110030410040101,101300401002320,112001321113132,101110434020010], + 301012002042004: [112002002003003,100012110101000,101202101000104,102311330240430,101023101000220,100002104103221,102231104040121,111331324131300,102303101002031,100010024302421], + 1031130111011101: [111120230020122,103100221440010,100021101000000,114301000000002,112124310203104,100113324103000,102001000221124,114123420002142,102023021321020,100040401020413], + 121111101011211: [102011214000000,102110111410144,101001100300012,101041104222000,103002201220000,112000202310100,110001102102020,101102101100112,101012031033100,112023100230412], + 220120010003121: [101003201002421,102034004000133,114440012312003,100102240002022,102112411140024,102113000210043,102114101120004,100421111011000,101010011034220,111232024102030], + 1200010024231441: [102000000200302,110001222134013,102021120200111,100303404100220,110101431000132,114310032322001,103240101202023,101004044212020,112000020222043,100400200010131], + 1040331000001422: [100141220000211,110042202002303,103102010212440,100021120412010,102002344013100,110002002200300,111200302214000], + 204002420040131: [103102300102243,102113020210120,102020000204032,101012310342300,111202004100121,102012014000404,114020404101101,102321320224101,114031000012100,100020004310022], + 104332041102000: [102120221022200,100003121032014,114000030020101,100030024102010,112044414003133,100120120112100], + 1000212001043011: [101011004212201,101010304000003,110032022002020,100214230430124,103031234000122,100400110020244,102044021101411,103230011412301,101100104002023,101042001021012], + 1400303014041020: [100231004220242,100021210200200,100400102040013,120020430310100,143112400002321,112301043200001,103040110122010,112202300110022,100002040002401], + 1140100000020024: [110040031224032,100024321230000,300401400322212,101200000042003,114122324002022,110000202000001,110244412120001,111300322200143,100110000002002,102202321104040], + 102100111103220: [110300202021130,101300231002120,103400104001022,100240020430431,114440420003022,110021010021210,100000024302220,100222021003140,100102404232033,100000000402000], + 1020212222412302: [101001040340004,101013004002011,101300011002044,112022334022101,101011324004222,101410401010030,103210241422022,114411312312124,103240001403000,102202204040220], + 1114042022220003: [102112320210140,101300300230001,112401120200210,102410220203104,112032242002404,101000001002320,100023404104311,102004410222200,101310201000040,140020203000100], + 1000203010041232: [131402001003121,100440420024144,114420000001024,102030414000201,100304111000014,103300031403210,100022131043110,102301201200000,102010021413001,102040300202332], + 1101401000001241: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 222103120002310: [100020121020300,103432001210300,112440134041000,100210240013000,110401214242400,101044214042221,100033201031241,110010114210202,102141000313022,110110114221031], + 202222041031201: [110400110003110,112314041101220,110233241214121,103221320102204,110123041320021,102103124031442,111001320042332,100101204231000,112111004021041,103212201410133], + 103210001132431: [112020042344001,111101122102222,100241000430420,103000114001000,102242024030234,100003344214000,114400300000221,103104024000023,100002104201130,102322420210320], + 204300312102103: [102101210213220,100030100410121,1001013211040100,102220300000443,110210103122411,1300102203020001,1132012124324031], + 100121100124302: [111333104124202,101000304014100,100040011023101,101123232010002,114421242204443,110100222001100,101004120224442,103102000121300,110010331230210,102030020224102], + 1104301232010301: [100000204102030,110210131301120,114102042311423,114100004002011,110423200004021,111200102222210,111140002113000,110201221301200,112001202341100,102240230230013], + 1143212012100021: [112100124023402,101020044011003,100002414210010,102010042000041,102242204040102,102321410240300,100021014100124,100130244302034,100122040012210,100014010104404], + 1100100144014024: [101301014221122,110422102110221,114220040000201,102102204022310,111040032200021,103030040121410,114040210022000,100404400013222,112010420241002,102241044033231], + 1200011200020320: [114020000030002,100113220020101,114031000022030,102014002000401,103103241421322,114121012340044,102000400240203,102104304023201,103310300140324,100002224244002], + 224111422001240: [103110210340021,1130420021212000,100000011034320], + 100142000000212: [103004201421221,1331041104430100,100104114230000,110102220031010,100202004104140,103020441400230,110141440120212,102030300140002,1032220014300112,103014011241012], + 1223023124102230: [100024000110221,114130014001202,110010220103020,111004100022110,114040210022000,111001344400222,101021204010011,100404410022320,103012101410102,111000000000411], + 1140214200020222: [110400112011100,103210220100310,110441010002400,102441030200210,103110314000100,100032134341034,114203104001000,100441001010204,101202240300141,114421000000000], + 321020201110003: [103332104032020], + 110031222100203: [100221004324212,110410331241133,103144224004012,101120011040200,103012400100023,100241044122010,101312004220321,100121014030221,100002011024214,114102034002301], + 241120202010001: [114210014110000,111101122102222,110034004420011,103000114001000,100003344214000,111022214113044,110043014410220,102322420210320,114124040000002,100112001021112], + 1441114102010010: [110441234224400,110030002000422,103100014031411,110000300424304,100032121024110,110013122130200,114020204102020,102402330230011,103121221400012,102022400211311], + 1101220210010332: [110202012100020,102303010241010,102120231343224,111342020011220,100314114322101,102230130203001,103100034001310,102021401324232,111222102243400,101004410311232], + 204031102120433: [100012110101000,102311330240430,101023101000220,100002104103221,102231104040121,100010024302421,100200204102022,101022400302010,100021210420202,112021004000202], + 1032002011243122: [111240220002100,110030344201413,101001014001021,110100001014311,102304244110431,100103224301304,114000100020200,102100322001021,102102100231000,102122000221020], + 140401111001310: [100021400101221,102241341113010,102300020241001,114100124100413,104130301242304,101001114012114,101141400302200,100002044101122,103342424024214,100100021040420], + 120002022131020: [103111001422000,101400004022100,100300041001121,101240004011021,101114000332010,112112211102024,114031212300211,102013110201200,102111022001024,103210431422030], + 201202212144011: [100012330001024,100140330020001,100020134300020,103102000100210,111224340011202,101140004203010,101220004013020,101400424021221,100101030022000,100001020120320], + 1412342302123042: [100002001013012,100000331201012,111210214440200,114120220214130], + 1421442321000022: [114400322311044,100101220101011,110000141123103,111121000014100,102420430204010,114204102320001,100102204302134,110012042101020,100021004103201,110200210404004], + 1040030400102003: [114201204111222,102004204041000,100104341010424,100004004102410,102301101004100,110432112111103,101104001101000,101000100342143,101012111001103,102411021400120], + 1122020030100101: [110110212010011,100000010101402,111144004103013,102412104022200,101441104023001,102123324004420,112202022022311,103020031400120,102000114010112,100110024300032], + 1100001224020200: [102040431121110,100400002201113,114111100021420,112024212301420,100300310140241,100240134323001,102111024000402,114321002320001,102042000222002,102001011100100], + 100124320044242: [114012304010103,101232404040100,100131204300010,103320304021024,102102020203131,102230214040023,114402004140023,100000301041003,100043204100144,101000304012013], + 101122031200001: [102300100220200,100002031032111,101012034000001,110003214210201,111222110012011,101000040310042,100000101020412,101204001012001,100111240012114,100410021011321], + 121240341110032: [112310431102204,112004300243012,100000320002140,110102301121440,110003402102211,102200121101000,102103010200134,110012210443400,112002212312240,100300004320113], + 110342020102200: [103134014000340,104103100010141,111101222240010,100040210411102,112014022314210,100000014100024,102010000221204,100110004102034,102040140220220,114010400014304], + 1001000133401201: [100012340410210,103420430121200,114020104101011,100002121032011,114210124000000,102144022000341,110102322010003,100022334312010,100401020020010,111002040001042], + 1030021130300002: [114430202311020,100020101024200,110431341000014,100342121000040,101003104003010,100011041020300,102140004000231,114003114122103,100400200020134,110303202102200], + 104022200021222: [114220040000201,100404400013222,110012130410040,100104101200201,111040100020010,112201010203210,103042320101230,100120430411222,110014314410140,103004004001222], + 1000204133231010: [114002044012422,100231201410110,112213013124000,1121420100113022,1001421031214242,100113202240102], + 1011101201001331: [110130314400100,100032431030100,112102024020402,114001030023421,102223300202003,114400202314210,102022004010240,102102010214442,103022110142241,103012000100422], + 1403120020132131: [100024000110221,114130014001202,110010220103020,111004100022110,114040210022000,111001344400222,101021204010011,100141021004020,103012101410102,111000000000411], + 1411000130310001: [102102031320011,102102031403230,100024004210111,100041140201301,102002100222202,102140021410400,102001041100103,100000120202410,102300004110122,102202334040220], + 122010104120003: [111102110012000,100000144104100,101000344010212,101033141030001,100104400021023,102111210230204,114003104032034,102200421003014,103214430100103,100131400100220], + 213211002241321: [101400001013200,110010104412000,102204424030220,112401002021204,100400300012210,101020304004102,100402032201300,100200201001120,100114004032011,102204004011102], + 1243021300001101: [100012400101400,111242212222022,101401140300101,101242000300000,100121211012110,102221220204211,100140304103400,100020210021010,100100120020120,100040004102010], + 104201402121120: [114003010024040,123102202010320,101020211140102,102104120200134,100120230012241,104210140212241,121133013031103,101112240323103,110043200023212,103441014002310], + 1100020000200200: [110013202003320,101031241000010,102120231343224,110030332100203,100314114322101,114404232310120,103100034001310,114002202210331,100031301020100,110111032140220], + 1000003000131100: [112410104010101], + 122200401300301: [102320204112110,102200311300000,114402200140311,111003002230111,114103020000000,111202220001030,120120044004103,110010201320402,103040221410110,111011020042020], + 1022204110102000: [100202440410010,102002041421011,200001320002101,120200122422404,102143140212042,100000021202031,320440130020000,140441120210201], + 222000030422000: [114102300004024,112102201102030,103222244003021,114021114023402,100340114211043,100210004343102,100033001220020,114233002340141,100001311234020,101114000330410], + 201001011100313: [101000224223002,112010012000201,112240000413000,101040201112304,100100301021212,111011024411424,102130000312131,100000101223200,101000231002312,102202210200000], + 1000101030142100: [110201021201020,110134000003002,111121302103104,101111120330403,102003030241110,100101321220213,100103024030023,100120034230102,222400011010100,100111201222040], + 1210430301324011: [102203004042010,114203042330220,100020001041410,114004014011110,102410004024030,103102211440104,111101100021200,100002020101023,111230040010002,114112000004001], + 202110204211313: [112020000230440,110002222201000,100112000402300,110041014413112,110004002133140,110122000020202,110421000100303,102040244041000,102100211143330,110421002110030], + 1100042002230001: [110111111010000,112230122030224,114120014004003,100010020003310,101042204010110,100002244111003,110131311200401,110441222110003,112000021112000,100103124033001], + 1141100033210301: [112224111100141,100040134340044,112004310224204,103043334040203,110422201312402,102120131401230,110302011332024,110200302024000,110210020104031,102041210224224], + 1111002300321004: [102231130213210,100043324210140,114113104123200,100023024211011,100003201021001,100122020011232,110002021121023,111102042213043,102300040221403,102201100200430], + 1003001021102020: [100000100100200,102010020203010,102200010200000,102001241410312,100000121042240,114444012310100,102330021000131,112041031114021,110400240002411,114432422322332], + 101001011200021: [100422000031421,102220021120430,100102000010243,112410034040040,111302304130401,100024334203210,103031410122401,100040021031201,103000300120001,110100000100314], + 1042100322112000: [101402011014002,100002200412020,100102000423142,114410012310230,114000332303001,100022224312021,102122421340210,114044240023401,102010100203212,103113030213000], + 1403323211112341: [110023401320200,102301224110000,110000312001020,102133211401043,102010214000003,114032204104044,103002010100104,102124011340031,102410110232000,100302000441000], + 1041313023011010: [103222114034232,103221204032410,100004004102410,101104001101000,103210120100203,101124011100242,103142210104020,114400240003003,102324221001114,112203001103411], + 1010021040010013: [112413224040101,100220100110400,101200031020230,102403004042342,101024001034211,111122004101222,114001012300002,102121100232012,114000222213021,114102330210021], + 132222044422000: [111121210031101,100013100100014,100000001020000,102000404002002,100120234300003,102100014000422,114010422330121,100001031220012,110020402100200,103044001403210], + 101210040201230: [112212320200423,100044011022224,102022031321021,102301011004011,102200111110200,102130001400000,102012100200021,112224304041202,102034010220333,111103044400100], + 140000140230042: [110040022130003,100030430422242,101120014204000,100100014230110,111002132202012,110201004241002,101000131142230,112001204023241,100104044230000,114022024012213], + 1010100002003421: [114101004121020,100013014102414,100034134300203,114202000000000,102323404112032,114312012320120,100000041020230,102041021121210,100031000101440,102010031444104], + 1000001204221103: [110204400000120,102001101130120,1000310103100002,103122114004113,102242301122200,101240010310200,110040230120420,100200020431202,101344140314114,114001002300400], + 1000030000400222: [111101144102000,101010020320000,102300310242221,102024101321401,100402132200000,114020000020300,111100300024000,103000001401041,100000134100202,100000321040000], + 132314401200020: [102101021412120,110024020421011,100042014310200,100003014314102,100040224102124,102100011000033,100011214102010,102112241342203,100002004200212,110010332201012], + 120102030344140: [114402404141241,100200400430003,114420102323300,110212022133311,101041210311410,110022004211030,110403010000304,101210021021243,100140024230240,112230240412241], + 110203113111041: [111144042240304,110301011234204,114211102321011,101001004012413,102000200201422,1001103242021023,102412004022002,103220124034124,111123114101021,100032204200023], + 1021000013324142: [110121100004131,102320000221020,110142020400012,114230344103210,103114211441300,103123200222442,101303414220001,100131000400012,103020200122310,100040004202103], + 120040000222023: [100210001210000,110202011000012,100011000420320,103102124000402,114232114004301,101140341100310,101010404221002,102221044031031,110010104201130,112422000202033], + 1001310121010311: [100200400430003,114420102323300,110112030401012,111112204404021,110404122110112,110403010000304,114100040214000,101210021021243,102412044040011,101010200320244], + 304124203440023: [100024000110221,102102204022310,114130014001202,110010220103020,111004100022110,114040210022000,111001344400222,101021204010011,103012101410102,111000000000411], + 100200232002010: [100034304101213,114002014100310,112313301100030,102101031412121,100020020121132,102102010220401,100001020100030,100021120201020,111000024404021,101202014010400], + }, +) diff --git a/profiling/mix_small.py b/profiling/mix_small.py new file mode 100644 index 0000000..6937df5 --- /dev/null +++ b/profiling/mix_small.py @@ -0,0 +1,102 @@ +config = some.Structure( + globalMap = { + 103310322020340: [100000031211103,101042000320420,100100001202021,112320301100420,110101024402203,112001202000203,112101112010031,102130400200010,100401014300441,103000401422033], + 110040120003212: [114413100031332,102101001412002,100210000032130,214000110100040,103031420121210,112114222301010,110133330100020,100001001203011,102210220202130,102200120234012], + 244402003102200: [110212012114431,100001140020000,100012101223021,110031301200114,114002020044120,100021004302202,102202200240222,114102010220042,102021301441201,104103102103201], + 122013242003223: [100014100100001,102100004130301,111120004100414,101034024000101,100021424301033,102003004003400,103340410140122,100102114100420,111012202111021,100103144302200], + 1120010021223330: [110332202020000,104120130021200,112421004012141,111100220022101,100021104201130,102224410201003,110030021010001,101300401002320,112001321113132,101110434020010], + 214100003030021: [102122000214201,100242141004122,102024240221040,110320011200230,100011114300334,102303004110022,100110201042101,110134201140010,112101044000202,100040024340013], + 1000220132200020: [102231130213210,103214010102022,102000402041014,100043324210140,100023024211011,102404021403141,100010004313001,100003201021001,100122020011232,100121031014040], + 1200041022422001: [100021300101110,103010301402112,100011401031000,100020034100101,100122214300222,103134021420204,102042210220100,100103200021130,103204214043011,103020320102002], + 1000232101122040: [110011414240022,102202310203222,100042001020203,102002320220202,100010044300003,114130210231020,103301410110110,112114324040000,102124031023100,100204104320231], + 110002000000001: [110010000111020,102011041320000,114240012324120,100022010022031,102014140200013,101240110302200,100031204311023,101232001021020,100012121040101,111243002222100], + 200211022142211: [102231130213210,103214010102022,100043324210140,102324014112020,102022004012201,100023024211011,111130210020000,102404021403141,100003201021001,100122020011232], + 114121130201204: [100040031020241,101100104000222,102324141000002,101010234004042,102041224010012,100411400030100,100002000102100,114340102322021,112033124022002,102120221120200], + 104101002123040: [100032320000112,103140011442322,100312120141341,111144020011120,112142204020032,110044031204131,114012010020012,100001420412010,100102110020102,103022000123142], + 241101103112120: [110333404433042,112240002043300,110021100132240,103104221443021,101100304000101,100202210410011,114402212310021,102411011111011,103020141414101,100113001040420], + 1004020030320422: [100022214203010,110310011234031,110123111300000,100020031041304,102120004000101,102020002000420,110100302010110,100422020030044,101220100303222,100002220411002], + 1041010100001110: [111124004101012,114103220220104,102120004001310,102430121110340,101021204000200,112141104020201,101200111020111,110001200422320,103210114021430,114223242332100], + 121103011132000: [110021104200001,110441140102024,111140124100100,110310020040401,100002024303323,110030002130201,102103320232241,110302000400221,110111001302000,110210304220000], + 1042022101004111: [110021104200001,111140124100100,110031301200114,102103320232241,110302000400221,110111001302000,110210304220000,102033124000111,111000212204213,110010324410130], + 102220010222003: [114003212210013,110302012103114,103023101400002,110010120440200,110024140022040,100002100100320,110100034200300,100401201010220,103200024021204,102100204000234], + 1442130103121040: [114413100031332,112121020204344,102211030203010,100210000032130,214000110100040,103031420121210,112114222301010,100001001203011,114214404142034,102210220202130], + 110204013021024: [110301402000211,103030201402004,110420104221220,103200004030020,100320014310021,102000110221110,110240214432004,102122141142000,103041204010000,114432234113040], + 100001440133234: [102111040210242,114110000002430,102010011412143,100424220032043,114013422300032,102021004001004,100131414303044,100201010110320,100000221030033,110101101120302], + 114002033000020: [100001121002141,102000040201003,101132131221321,100004440004031,102002011033030,110310300003402,110220022132003,101001000302103,110044112100220,100010120031210], + 112123022000131: [100304201000221,100112021020320,103010001422020,102300124023122,114221004100020,100002100124101,102304100210334,100403210010142,112003100241220,102204304000304], + 1143001230040001: [101033124003122,100313144100202,103201004024412,114014222302011,103011020110211,110203420111140,111003412201430,101411214000203,110222422042203], + 1002403200000231: [100122004300410,102140014001101,102000104012232,112400202020003,102000224000011,114122134140002,102101010202004,114400202310210,100042030201341,112233332034000], + 1003123041101031: [110043132100300,102220120203200,100002004201122,110132031134031,1320303202002000,1321200010022312,110130330012140,114102134002330,140403400240000,100003230110201], + 242220101103400: [111130112100210,102202200240222,110131044200121,100100004102234,110223332120231,100001024301322,114013044102010,114220114140122,101023021034304,110200210110130], + 121030040400021: [110011011212100,101134030011000,103220211421421,110123230124040,131000001020102,112200412033030,110420001000202,100102110402220,110412310030001,114012022302022], + 100104011300401: [110320414420310,110100100101041,100420124100211,103010211222002,101040120320230,110013021300010,101043234000412,101220000040002,100422001002123,114010010010002], + 1004003211220032: [102400100230000,101100300302102,114120420223002,100002210201212,102302020212101,112410424012010,100030004104210,103030201434002,110232110004010,103021201430000], + 223011102020040: [110012420131001,100132040031022,100020310000200,100220004030002,110020002003334,110014000442004,101441204020001,102014201411102,103231320100042,104121201242032], + 100200110422111: [103100221440010,114003344011001,100021101000000,102140000212141,101014201030204,101203001010111,102424114020143,100031201030102,101041001003300,114012444020220], + 134300111030221: [112100124023402,101020044011003,100002414210010,102010042000041,102242204040102,100021014100124,100130244302034,100122040012210,100014010104404,101020104000001], + 114001000330100: [401142101000022,400114001102410,102100000012031,431232000323104,1012100023110102,232023302143031,120200122422404,1040100003200241,111414004440203,1020220210340010], + 211222012120321: [112000112000031,100121214300000,102123214020000,102022124012030,114002320022312], + 1122000200402140: [102401141113031,103042420143020,102304314110202,110210400002012,113032012204012,112310002020302,100204311000400,100403012200201,112002111121013,114211100001224], + 332000024200013: [102120010220042,110103312142034,102210210312302,101120100320100,114140014100000,102110004002301,100130020001030,112022100213011,100101231202322,111210020001013], + 120041442412123: [102133011413110,111001200041102,101223020300040,102034324000220,100210000032400,101230020303000,111340130010314,110200422121211,110214220002020,112220414010040], + 1011011320300100: [100102024301030,100111134302041,100112234000041,110004244214343,101002101020003,102214021120301,114221224100022,101330210310300,112003021111000,102012141134211], + 220020021000101: [100301001000202,104101112102403,100023121223031,114201432320014,120000002023011,102133120200123,101014020301201,102000031130401,101010111002141,114123124143310], + 1024011342000021: [102001001130100,111204203012002,124020002020003,122222120003214,133332002141010,144000013213001,124010030100142,112310202021010,110014020020011,100140044020011], + 1131011002310011: [102230040200031,110122001010214,114043140010022,102101204000010,110022300420031,100100401040001,114230230000123,100222024320003,103323001400013,114013012300240], + 1142024120224002: [102203344011410,100021324100000,102103430210003,100012014300120,102414014022212,102012220241003,101004411032102,101430211012120,100204021000012,103242044020102], + 1100004410231120: [110013202003320,101031241000010,102120231343224,110030332100203,100314114322101,114404232310120,103100034001310,114002202210331,100031301020100,110111032140220], + 1440220030001122: [114010330030011,103021220104200,101010020320000,112000210211020,100010324210003,101000000343443,110002400011111,100402132200000,111100300024000,103144040104204], + 121414301110004: [110144240011020,110413401240204,112000244001222,114441114123013,103220211421421,114000012334102,101000014012442,100312401002102,111022210021013,103110001420121], + 130004004220120: [111240340004003,102021024000010,111101222244030,112011012004300,102300010242330,102000401120420,102004012043122,114011102210402,100120001014040,114300100000041], + 1013303000401020: [101000024004442,100002100000100,110130030020000], + 220041302111231: [100002014200331,100034244210020,102012004000003,100411000030110,102041201121230,103011014042120,100000030120242,102110400210023,101012204221200,111212422222300], + 1000031031200013: [101302134233230,100000130010033,101030404212000,114102224000201,100022021041122,100020001042002,100013011020311,100120041020012,102012204000242,114143024003322], + 1000303301100221: [111333104124202,101000304014100,100040011023101,110301030010140,104100002101431,101123232010002,114421242204443,110100222001100,103102000121300,110010331230210], + 1410211342331412: [111002100000102,114021010040140,114222302321101,102101024002121,110014024202014,110220130100010,100020011030330,102404221402210,110203022032320,101222014230110], + 1411020122202044: [100141401021003,102010000231120,101000400320211,101001010300214,103010020142023,110132002212113,110010100040100,102101002002002,111020302232033,110224030114311], + 101010042001102: [101221020040220,100103104302044,101041030320401,102141212000200,101203121020430,102020004000014,100000211023014,114144014122041,100201111002224,101410304041000], + 204204011102020: [100212030414010,101400004022210,102031021441200,101200020303202,102301324112020,111340300010010,102013224003020,103013020123142,102240344041020,102140202001100], + 240000420312002: [110002004410202,102103114000024,102240221000001,112041002002124,114000024101102,140343100002103,400200234320200,100020124204330,100001424102041,100100021040230], + 1030000001422430: [102343230224321,103211200100400,102112231020231,100022004300020,102320000240102,100042144200000,102030304001101,100020420121003,103020004011414,100001104301200], + 1104234221030010: [110000322130121,101023001002020,111300222202234,100200001210021,103204230111030,104130020011020,101114422122000,102001314013400,114110414140400,111201100011141], + 121341130003000: [111102004100101,102021100220101,114000040010421,112042110220004,100000214240410,100433201004014,102301102004413,102003000220111,102010100204023,102414040230400], + 100101220022002: [100010024102110,101041200320012,114303400002201,110204211000331,112121014003422,114430102311021,100240444100022,103004411424400,111014002140322], + 1023303420422001: [100043104240004,110002034200042,100001240100033,114100304002030,102100001340122,112030010234104,103414101212410,100123021223100,112302011102312,101020030343002], + 101114102124321: [110403244220202,103113014002100,110120400402324,100402340010310,112010020211000,100102200000211,103030201240100,102300210210222,114100332340213,111031030024010], + 1422302020100030: [114020000030002,114031000022030,100201211003004,102014002000401,103103241421322,114121012340044,102000400240203,102104304023201,103310300140324,100002224244002], + 1121202400231120: [101211201202134,103120104030100,100004000100101,102020030220200,110031404423144,110003434410403,111110000014401,100000204312321,101004000304012,110300121220201], + 1042001221000013: [114032104100141,101213114040141,102210101002412,111140100011101,110122421241103,112001144002010,101013030304101,100012011022000,102000004000013,102021241324040], + 1102433033042110: [110104112010103,111102004100101,100122004300410,102202414041044,102140014001101,102000104012232,102021100220101,114443330001442,100230120001003,114000040010421], + 100103201011144: [110102401201204,102400100230000,100212030414010,101200020303202,114120420223002,102013224003020,100002210201212,103013020123142,102302020212101,114303340000001], + 240343043023011: [110120144200000,114022412330004,101200221022044,110241112020204,100002004104004,102100224000210,102310140240012,100014204201000,102103321411004,100400001001300], + 1020301032424304: [101302134233230,100000130010033,101030404212000,114102224000201,100431000032001,100020001042002,100013011020311,102103331400000,100120041020012,100020001041231], + 114200022220040: [100014100100001,102100004130301,111120004100414,101034024000101,101243024011000,103340410140122,100010021221221,111012202111021,100103144302200,101414100300221], + 142041243300010: [102102002002242,101130104022002,101230331020012,100004244210201,102420124024204,122312222240401,102041014011340,110200130004300,100140101012000,101400000302141], + 1002203102111022: [100434000032200,110004020020022,114032412303041,112000301122111,102020130212402,100010001020000,200000020021022,114321212322303,112302112002211,114202002333330], + 1110102121041413: [101012310301211,103112200123144,114242304004011,102302200241241,110001420021023,110201040003402,112301421130130,110020012100302,114412202320010,110021030030202], + 114020200220012: [102010114022011,103340041403223,114002200000421,101020321002002,114302210010001,114030004104220,100104004301000,102443211401140,102301041000014,100001111201214], + 202011212123200: [102203301123001,103210400110122,101112020300011,114104302341000,100400201010000,102244400201444,101010001000121,102304000220032,102002131132000,100000031024222], + 201032103003132: [110212041114210,113210300100002,112404024011000,102131034000220,111212124130140,101002014013010,103402020120010,112110100230023,112003044002004,103020200102200], + 120222032001012: [110121100004131,111400214442024,111122200021102,101041100300001,102140011440001,101011220342010,110200004221020,103114211441300,110000222010004,100114000101041], + 1100013040001020: [100003031030034,101001044211204,102100010233022,102120400212001,114313022302101,103001324000110,100002014200021,102300401001010,103212320212011,111120034400000], + 1001031021300022: [102000020220000,101020104000040,114412142320040,100003044100101,114012402332300,102220211122102,101010110302010,100032121020101,100013224313301,100012244240030], + 124000010122242: [100032320000112,103140011442322,100312120141341,111144020011120,112142204020032,110044031204131,114012010020012,100001420412010,100102110020102,102002204001140], + 1121211020204132: [110020301320101,102014001130210,110401041140300,110002302201420,102202001120002,110200010003201,102421004041011,102240040202421,101001110300111,100130004300103], + 121320202004301: [111014240041102,101100004200110,112021221130424,112200041103002,110400040402041,112001011112202,100112004304314,100232041001122,100223030001010,100104231000300], + 1024242230240244: [110322104424202,101202421002031,102102220312102,103004204021310,112220102043102,110012310020200,102030130241300,103030120100220,100232224340041,112400002011010], + 1002100010130110: [101400001011042,100002011020211,100100110010010,111110002213142,100002131030310,111102214100400,103220201402330,102321000221140,103113124030200,102110300311400], + 200010402222410: [101210320301302,102100221340112,100114104101001,114002244103320,101023221000031,101400014040400,102012034000402,114221004002212,102100122002001,101000011021414], + 112300020202111: [103141411420221,122102400312000,110002100110002,1340024302404122,100002001043010,113110330121030,410020013004430,1002300040412102,1210020204140003,123211320000102], + 100102203210034: [102023021100022,111200302222011,112040241120204,111000022200000,100010011232324,110220030000133,110000330430311,101211221014003,103111230120100,102221220200021], + 1021001032000012: [102020010203200,100011144312020,102011204001010,102001410221023,110130201302200,103041021430301,101100440320434,114000402211404,101000100302003,110000030430422], + 1031102424140120: [100011010414200,111121102240240,102002121101110,102403100202003,110000100041101,100400000010033,100101211001320,101141020321000,103224101400400,102000002043020], + 102001021434201: [110131122012210,114010200040441,110032014420232,100000344100100,111304022202211,102302011002003,102011021121200,100012441030002,110222042022111,103131004002200], + 220100132400104: [1010400230221020,111320012221132,102302144110440,114140004123122,102143202000400,111020002202333,101321311004010,102110241342210,114122302311011,100002320411400], + 1110121023020002: [100022041001002,111240340004003,111101222244030,114032424122040,112011012004300,101021401003220,100301020420101,102002202000000,100022024100041,102010410213111], + 1042030001044121: [101230040301234,110033032100000,102303014024221,100100224304110,100400432200321,100020200012311,114140144122230,101400201102014,100000020004004,101040040303102], + 1100100224104011: [111130112100210,102202200240222,110131044200121,100100004102234,101023014004000,110223332120231,100001024301322,114013044102010,114220114140122,110200210110130], + 212002042300000: [100030220100110,110011202100142,112400102013231,114012002212100,100002114314022,114203110001031,112030122000211,111004012200210,100413131013301,110001102103432], + 221001240043040: [100420021010013,112101302302202,102212011120200,102344111104233,100432104320110,114021014020000,102121321340000,114200214002024,100111221011100,100023104101340], + 1040021200420124: [100042111220111,112220100202000,100042041220010,100403211010100,103240301400123,114102210214041,100021300103041,101010204000242,111334004121414,114101000213410], + }, +) diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..9da7611 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,246 @@ +# Example configuration for Black. + +# NOTE: you have to use single-quoted strings in TOML for regular expressions. +# It's the equivalent of r-strings in Python. +# Multiline strings are treated as verbose regular expressions by Black. +# Use [ ] to denote a significant space character. + +[tool.black] +line-length = 88 +target-version = ["py310"] +include = '\.pyi?$' +extend-exclude = ''' +/( + # The following are specific to Black, you probably don't want those. + tests/data/ + | profiling/ +) +''' +# We use the unstable style for formatting Black itself. If you +# want bug-free formatting, you should keep this off. If you want +# stable formatting across releases, you should also keep `preview = true` +# (which is implied by this flag) off. +unstable = true + +# Build system information and other project-specific configuration below. +# NOTE: You don't need this in your own Black configuration. + +[build-system] +requires = ["hatch-fancy-pypi-readme", "hatch-vcs>=0.3.0", "hatchling>=1.27.0"] +build-backend = "hatchling.build" + +[project] +name = "black" +description = "The uncompromising code formatter." +license = "MIT" +license-files = ["LICENSE"] +requires-python = ">=3.10" +authors = [{ name = "Łukasz Langa", email = "lukasz@langa.pl" }] +keywords = ["automation", "autopep8", "formatter", "gofmt", "pyfmt", "rustfmt", "yapf"] +classifiers = [ + "Development Status :: 5 - Production/Stable", + "Environment :: Console", + "Intended Audience :: Developers", + "Operating System :: OS Independent", + "Programming Language :: Python", + "Programming Language :: Python :: 3 :: Only", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", + "Programming Language :: Python :: 3.14", + "Programming Language :: Python :: 3.15", + "Topic :: Software Development :: Libraries :: Python Modules", + "Topic :: Software Development :: Quality Assurance", +] +dependencies = [ + "click>=8.0.0", + "mypy-extensions>=0.4.3", + "packaging>=22.0", + "pathspec>=1.0.0", + "platformdirs>=2", + "pytokens~=0.4.0", + "tomli>=1.1.0; python_version<'3.11'", + "typing-extensions>=4.0.1; python_version<'3.11'", +] +dynamic = ["readme", "version"] + +[project.optional-dependencies] +colorama = ["colorama>=0.4.3"] +uvloop = [ + "uvloop>=0.15.2; sys_platform != 'win32'", + "winloop>=0.5.0; sys_platform == 'win32'" +] +d = ["aiohttp>=3.10"] +jupyter = ["ipython>=7.8.0", "tokenize-rt>=3.2.0"] + +[dependency-groups] +hatch = ["hatch==1.15.1", "hatch-fancy-pypi-readme", "hatch-vcs", "virtualenv<21.0.0"] +cibw = ["cibuildwheel==3.4.0", "pypyp"] +pyinstaller = ["pyinstaller"] + +dev = [{ include-group = "cov-tests" }, { include-group = "tox" }, "pre-commit"] +cov-tests = [ + { include-group = "coverage" }, + { include-group = "tests" }, + "pytest-cov>=4.1.0", +] +docs = [ + "docutils==0.22.4", + "furo==2025.12.19", + "myst-parser==5.0.0", + "sphinx-copybutton==0.5.2", + "sphinx==9.1.0", + "sphinxcontrib-programoutput==0.20", +] + +tox = ["tox>=4.22"] +tests = ["pytest>=7", "pytest-xdist>=3.0.2"] +coverage = ["coverage>=5.3"] + +fuzz = [{ include-group = "coverage" }, "hypothesis", "hypothesmith"] +diff-shades = [ + "diff-shades @ https://github.com/ichard26/diff-shades/archive/stable.zip", +] +diff-shades-comment = ["click>=8.1.7", "packaging>=22.0", "urllib3"] + +width-table = ["wcwidth==0.2.14"] + +[project.scripts] +black = "black:patched_main" +blackd = "blackd:patched_main [d]" + +[project.entry-points."validate_pyproject.tool_schema"] +black = "black.schema:get_schema" + +[project.urls] +Documentation = "https://black.readthedocs.io/" +Changelog = "https://github.com/psf/black/blob/main/CHANGES.md" +Repository = "https://github.com/psf/black" +Issues = "https://github.com/psf/black/issues" + +[tool.hatch.metadata.hooks.fancy-pypi-readme] +content-type = "text/markdown" +fragments = [{ path = "README.md" }, { path = "CHANGES.md" }] + +[tool.hatch.version] +source = "vcs" + +[tool.hatch.build.hooks.vcs] +version-file = "src/_black_version.py" +template = """ +version = "{version}" +""" + +[tool.hatch.build.targets.sdist] +exclude = ["/profiling"] + +[tool.hatch.build.targets.wheel] +only-include = ["src"] +sources = ["src"] +# Note that we change the behaviour of this flag below +macos-max-compat = true + +[tool.hatch.build.targets.wheel.hooks.mypyc] +enable-by-default = false +dependencies = ["hatch-mypyc>=0.16.0", "mypy==1.20.2"] +require-runtime-dependencies = true +exclude = [ + # There's no good reason for blackd to be compiled. + "/src/blackd", + # Not performance sensitive, so save bytes + compilation time: + "/src/blib2to3/__init__.py", + "/src/blib2to3/pgen2/__init__.py", + "/src/black/output.py", + "/src/black/concurrency.py", + "/src/black/files.py", + "/src/black/report.py", + # Breaks the test suite when compiled (and is also useless): + "/src/black/debug.py", + # Compiled modules can't be run directly and that's a problem here: + "/src/black/__main__.py", +] +mypy-args = ["--ignore-missing-imports"] +options = { debug_level = "0" } + +[tool.cibuildwheel] +build-verbosity = 1 + +# So these are the environments we target: +# - Python: CPython 3.10+ only +# - Architecture (64-bit only): amd64 / x86_64, universal2, and arm64 +# - OS: Linux (no musl), Windows, and macOS +build = "cp31*" +skip = [ + "*-manylinux_i686", + "*-musllinux_*", + "*-win32", + "pp*", + "cp31?t-*", # mypyc doesn't have great support for free threaded builds +] + +test-groups = ["tests"] +test-command = 'pytest {project} -k "not incompatible_with_mypyc" -n auto' +test-extras = ["d", " jupyter"] +# Skip trying to test arm64 builds on Intel Macs. (so cross-compilation doesn't +# straight up crash) +test-skip = ["*-macosx_arm64", "*-macosx_universal2:arm64"] + +[tool.cibuildwheel.environment] +HATCH_BUILD_HOOKS_ENABLE = "1" +MYPYC_OPT_LEVEL = "3" +MYPYC_DEBUG_LEVEL = "0" +CC = "clang" + +[tool.cibuildwheel.linux] +manylinux-x86_64-image = "manylinux_2_28" +before-build = ["yum install -y clang"] + +[tool.isort] +atomic = true +profile = "black" +line_length = 88 +skip_gitignore = true +skip_glob = ["tests/data", "profiling"] +known_first_party = ["black", "blib2to3", "blackd", "_black_version"] + +[tool.pytest.ini_options] +# Option below requires `tests/optional.py` +addopts = "--strict-config --strict-markers" +optional-tests = [ + "no_blackd: run when `d` extra NOT installed", + "no_jupyter: run when `jupyter` extra NOT installed", +] +markers = ["incompatible_with_mypyc: run when testing mypyc compiled black"] +xfail_strict = true +filterwarnings = ["error"] +[tool.coverage.report] +omit = ["src/blib2to3/*", "tests/data/*", "*/site-packages/*", ".tox/*"] +[tool.coverage.run] +relative_files = true +branch = true + +[tool.mypy] +# Specify the target platform details in config, so your developers are +# free to run mypy on Windows, Linux, or macOS and get consistent +# results. +python_version = "3.10" +mypy_path = "src" +strict = true +strict_bytes = true +local_partial_types = true +# Unreachable blocks have been an issue when compiling mypyc, let's try to avoid 'em in the first place. +warn_unreachable = true +implicit_reexport = true +show_error_codes = true +show_column_numbers = true + +[[tool.mypy.overrides]] +module = ["pathspec.*", "IPython.*", "colorama.*", "tokenize_rt.*", "uvloop.*"] +ignore_missing_imports = true + +# CI only checks src/, but in case users are running LSP or similar we explicitly ignore +# errors in test data files. +[[tool.mypy.overrides]] +module = ["tests.data.*"] +ignore_errors = true diff --git a/scripts/__init__.py b/scripts/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/scripts/check_pre_commit_rev_in_example.py b/scripts/check_pre_commit_rev_in_example.py new file mode 100644 index 0000000..0dd9e9a --- /dev/null +++ b/scripts/check_pre_commit_rev_in_example.py @@ -0,0 +1,63 @@ +""" +Check that the rev value in the example pre-commit configuration matches +the latest version of Black. This saves us from forgetting to update that +during the release process. + +Why can't we just use `rev: stable` and call it a day? Well pre-commit +won't auto update the hook as you may expect (and for good reasons, some +technical and some pragmatic). Encouraging bad practice is also just +not ideal. xref: https://github.com/psf/black/issues/420 +""" + +import os +import sys + +import commonmark +import yaml +from bs4 import BeautifulSoup + + +def main(changes: str, content: str, filename: str) -> None: + changes_html = commonmark.commonmark(changes) + changes_soup = BeautifulSoup(changes_html, "html.parser") + headers = changes_soup.find_all("h2") + latest_tag, *_ = ( + (header.string or "").removeprefix("Version ") + for header in headers + if header.string != "Unreleased" + ) + + source_version_control_html = commonmark.commonmark(content) + source_version_control_soup = BeautifulSoup( + source_version_control_html, "html.parser" + ) + codeblocks = source_version_control_soup.find_all(class_="language-yaml") + + for codeblock in codeblocks: + parsed = yaml.safe_load(codeblock.string) # type: ignore[arg-type] + if not isinstance(parsed, dict): + return + pre_commit_rev = parsed["repos"][0]["rev"] + if not pre_commit_rev == latest_tag: + print( + f"Please set the rev in ``{filename}`` to be the latest one.\n" + f"Expected {latest_tag}, got {pre_commit_rev}.\n" + ) + sys.exit(1) + + +if __name__ == "__main__": + with open("CHANGES.md", encoding="utf-8") as fd: + changes = fd.read() + with open( + os.path.join("docs", "integrations", "source_version_control.md"), + encoding="utf-8", + ) as fd: + content = fd.read() + main(changes, content, "source_version_control.md") + with open( + os.path.join("docs", "guides", "using_black_with_jupyter_notebooks.md"), + encoding="utf-8", + ) as fd: + content = fd.read() + main(changes, content, "using_black_with_jupyter_notebooks.md") diff --git a/scripts/check_version_in_basics_example.py b/scripts/check_version_in_basics_example.py new file mode 100644 index 0000000..f84316e --- /dev/null +++ b/scripts/check_version_in_basics_example.py @@ -0,0 +1,54 @@ +""" +Check that the rev value in the example from ``the_basics.md`` matches +the latest version of Black. This saves us from forgetting to update that +during the release process. +""" + +import os +import sys + +import commonmark +from bs4 import BeautifulSoup + + +def main(changes: str, the_basics: str) -> None: + changes_html = commonmark.commonmark(changes) + changes_soup = BeautifulSoup(changes_html, "html.parser") + headers = changes_soup.find_all("h2") + tags = [] + for header in headers: + text = header.string or "" + if text == "Unreleased": + continue + # Strip "Version " prefix if present + tags.append(text.removeprefix("Version ")) + latest_tag = tags[0] + + the_basics_html = commonmark.commonmark(the_basics) + the_basics_soup = BeautifulSoup(the_basics_html, "html.parser") + version_examples = [ + code_block.string + for code_block in the_basics_soup.find_all(class_="language-console") + if "$ black --version" in code_block.string # type: ignore[operator] + ] + + for tag in tags: + for version_example in version_examples: + if tag in version_example and tag != latest_tag: # type: ignore[operator] + print( + "Please set the version in the ``black --version`` " + "examples from ``the_basics.md`` to be the latest one.\n" + f"Expected {latest_tag}, got {tag}.\n" + ) + sys.exit(1) + + +if __name__ == "__main__": + with open("CHANGES.md", encoding="utf-8") as fd: + changes = fd.read() + with open( + os.path.join("docs", "usage_and_configuration", "the_basics.md"), + encoding="utf-8", + ) as fd: + the_basics = fd.read() + main(changes, the_basics) diff --git a/scripts/diff_shades_gha_helper.py b/scripts/diff_shades_gha_helper.py new file mode 100644 index 0000000..def10db --- /dev/null +++ b/scripts/diff_shades_gha_helper.py @@ -0,0 +1,231 @@ +"""Helper script for psf/black's diff-shades Github Actions integration. + +diff-shades is a tool for analyzing what happens when you run Black on +OSS code capturing it for comparisons or other usage. It's used here to +help measure the impact of a change *before* landing it (in particular +posting a comment on completion for PRs). + +This script exists as a more maintainable alternative to using inline +Javascript in the workflow YAML files. The revision configuration and +resolving, caching, and PR comment logic is contained here. + +For more information, please see the developer docs: + +https://black.readthedocs.io/en/latest/contributing/gauging_changes.html#diff-shades +""" + +import json +import os +import platform +import pprint +import subprocess +import sys +from base64 import b64encode +from os.path import dirname, join +from pathlib import Path +from typing import Any, Final + +import click +import urllib3 +from packaging.version import Version + +COMMENT_FILE: Final = ".pr-comment.md" +DIFF_STEP_NAME: Final = "Generate HTML diff report" +DOCS_URL: Final = ( + "https://black.readthedocs.io/en/latest/contributing/gauging_changes.html#diff-shades" +) +SHA_LENGTH: Final = 10 +GH_API_TOKEN: Final = os.getenv("GITHUB_TOKEN") +REPO: Final = os.getenv("GITHUB_REPOSITORY", default="psf/black") +USER_AGENT: Final = f"{REPO} diff-shades workflow via urllib3/{urllib3.__version__}" +http = urllib3.PoolManager() + + +def set_output(name: str, value: str) -> None: + if len(value) < 200: + print(f"[INFO]: setting '{name}' to '{value}'") + else: + print(f"[INFO]: setting '{name}' to [{len(value)} chars]") + + if "GITHUB_OUTPUT" in os.environ: + if "\n" in value: + # https://docs.github.com/en/actions/using-workflows/workflow-commands-for-github-actions#multiline-strings + delimiter = b64encode(os.urandom(16)).decode() + value = f"{delimiter}\n{value}\n{delimiter}" + command = f"{name}<<{value}" + else: + command = f"{name}={value}" + with open(os.environ["GITHUB_OUTPUT"], "a") as f: + print(command, file=f) + + +def http_get(url: str, *, is_json: bool = True, **kwargs: Any) -> Any: + headers = kwargs.get("headers") or {} + headers["User-Agent"] = USER_AGENT + if "github" in url: + if GH_API_TOKEN: + headers["Authorization"] = f"token {GH_API_TOKEN}" + headers["Accept"] = "application/vnd.github.v3+json" + kwargs["headers"] = headers + + r = http.request("GET", url, **kwargs) + if is_json: + data = json.loads(r.data.decode("utf-8")) + else: + data = r.data + print(f"[INFO]: issued GET request for {r.geturl()}") + if not (200 <= r.status < 300): + pprint.pprint(dict(r.info())) + pprint.pprint(data) + raise RuntimeError(f"unexpected status code: {r.status}") + + return data + + +def get_latest_revision(ref: str) -> str: + data = http_get( + f"https://api.github.com/repos/{REPO}/commits", + fields={"per_page": "1", "sha": ref}, + ) + assert isinstance(data[0]["sha"], str) + return data[0]["sha"] + + +def get_pr_branches(pr: int | None = None) -> tuple[Any, Any, int]: + if not pr: + pr_ref = os.getenv("GITHUB_REF") + assert pr_ref is not None + pr = int(pr_ref[10:-6]) + + data = http_get(f"https://api.github.com/repos/{REPO}/pulls/{pr}") + assert isinstance(data["base"]["sha"], str) + assert isinstance(data["head"]["sha"], str) + return data["base"], data["head"], pr + + +def get_pypi_version() -> Version: + data = http_get("https://pypi.org/pypi/black/json") + versions = [Version(v) for v in data["releases"]] + sorted_versions = sorted(versions, reverse=True) + return sorted_versions[0] + + +@click.group() +def main() -> None: + pass + + +@main.command("config", help="Acquire run configuration and metadata.") +def config() -> None: + import diff_shades # type: ignore[import-not-found] + + jobs = [{"mode": "preview-new-changes", "style": "preview"}] + + event = os.getenv("GITHUB_EVENT_NAME") + if event == "push": + # Push on main, let's use PyPI Black as the baseline. + baseline_name = str(get_pypi_version()) + baseline_cmd = f"git checkout {baseline_name}" + + target_rev = os.getenv("GITHUB_SHA") + assert target_rev is not None + target_name = "main-" + target_rev[:SHA_LENGTH] + target_cmd = f"git checkout {target_rev}" + + elif event == "pull_request": + jobs.insert(0, {"mode": "assert-no-changes", "style": "stable"}) + # PR, let's use the PR base as the baseline. + base, head, pr_num = get_pr_branches() + + baseline_rev = get_latest_revision(base["ref"]) + baseline_name = f"{base['ref']}-{baseline_rev[:SHA_LENGTH]}" + baseline_cmd = f"git checkout {baseline_rev}" + + target_name = f"pr-{pr_num}-{head['sha'][:SHA_LENGTH]}" + target_cmd = f"gh pr checkout {pr_num}\ngit merge origin/{base['ref']}" + else: + raise ValueError(f"Unknown event {event}") + + env = f"{platform.system()}-{platform.python_version()}-{diff_shades.__version__}" + for entry in jobs: + entry["baseline-analysis"] = f"{entry['style']}-{baseline_name}.json" + entry["baseline-setup-cmd"] = baseline_cmd + entry["baseline-cache-key"] = f"{env}-{baseline_name}-{entry['style']}" + + entry["target-analysis"] = f"{entry['style']}-{target_name}.json" + entry["target-setup-cmd"] = target_cmd + + set_output("matrix", json.dumps(jobs, indent=None)) + pprint.pprint(jobs) + + +@main.command("comment-body", help="Generate the body for a summary PR comment.") +@click.argument("baseline", type=click.Path(exists=True, path_type=Path)) +@click.argument("target", type=click.Path(exists=True, path_type=Path)) +@click.argument("style") +@click.argument("mode") +def comment_body(baseline: Path, target: Path, style: str, mode: str) -> None: + cmd = ( + f"{sys.executable} -m diff_shades --no-color " + f"compare {baseline} {target} --quiet --check" + ).split(" ") + proc = subprocess.run(cmd, stdout=subprocess.PIPE, encoding="utf-8") + if proc.returncode: + run_id = os.getenv("GITHUB_RUN_ID") + jobs = http_get( + f"https://api.github.com/repos/{REPO}/actions/runs/{run_id}/jobs", + )["jobs"] + job = next(j for j in jobs if j["name"] == f"compare / {mode}") + diff_step = next(s for s in job["steps"] if s["name"] == DIFF_STEP_NAME) + diff_url = f"{job['html_url']}#step:{diff_step['number']}:1" + + body = ( + "
" + f"--{style} style " + f'(View full diff):' + f"
{proc.stdout.strip()}
" + "
" + ) + else: + body = f"--{style} style: no changes" + + filename = f".{style}{COMMENT_FILE}" + print(f"[INFO]: writing comment details to {filename}") + with open(filename, "w", encoding="utf-8") as f: + f.write(body) + + +@main.command("comment-details", help="Get PR comment resources from a workflow run.") +@click.argument("pr") +@click.argument("run-id") +@click.argument("styles", nargs=-1) +def comment_details(pr: int, run_id: str, styles: tuple[str, ...]) -> None: + base, head, _ = get_pr_branches(pr) + + lines = [ + f"**diff-shades** results comparing this PR ({head['sha']}) to {base['ref']}" + f" ({base['sha']}):" + ] + for style_file in styles: + with open( + join(dirname(__file__), "..", style_file), + "r", + encoding="utf-8", + ) as f: + content = f.read() + lines.append(content) + + lines.append("---") + + lines.append( + f"[**What is this?**]({DOCS_URL}) | " + f"[Workflow run](https://github.com/psf/black/actions/runs/{run_id}) | " + "[diff-shades documentation](https://github.com/ichard26/diff-shades#readme)" + ) + + body = "\n\n".join(lines) + set_output("comment-body", body) + + +if __name__ == "__main__": + main() diff --git a/scripts/fuzz.py b/scripts/fuzz.py new file mode 100644 index 0000000..4915f3f --- /dev/null +++ b/scripts/fuzz.py @@ -0,0 +1,73 @@ +"""Property-based tests for Black. + +By Zac Hatfield-Dodds, based on my Hypothesmith tool for source code +generation. You can run this file with `python`, `pytest`, or (soon) +a coverage-guided fuzzer I'm working on. +""" + +import hypothesmith +from hypothesis import HealthCheck, given, settings +from hypothesis import strategies as st + +import black + + +# This test uses the Hypothesis and Hypothesmith libraries to generate random +# syntactically-valid Python source code and run Black in odd modes. +@settings( + max_examples=1000, # roughly 1k tests/minute, or half that under coverage + derandomize=True, # deterministic mode to avoid CI flakiness + deadline=None, # ignore Hypothesis' health checks; we already know that + suppress_health_check=list(HealthCheck), # this is slow and filter-heavy. +) +@given( + # Note that while Hypothesmith might generate code unlike that written by + # humans, it's a general test that should pass for any *valid* source code. + # (so e.g. running it against code scraped of the internet might also help) + src_contents=hypothesmith.from_grammar() | hypothesmith.from_node(), + # Using randomly-varied modes helps us to exercise less common code paths. + mode=st.builds( + black.FileMode, + line_length=st.just(88) | st.integers(0, 200), + string_normalization=st.booleans(), + preview=st.booleans(), + is_pyi=st.booleans(), + magic_trailing_comma=st.booleans(), + ), +) +def test_idempotent_any_syntactically_valid_python( + src_contents: str, mode: black.FileMode +) -> None: + # Before starting, let's confirm that the input string is valid Python: + compile(src_contents, "", "exec") # else the bug is in hypothesmith + + # Then format the code... + dst_contents = black.format_str(src_contents, mode=mode) + + # And check that we got equivalent and stable output. + black.assert_equivalent(src_contents, dst_contents) + black.assert_stable(src_contents, dst_contents, mode=mode) + + # Future test: check that pure-python and mypyc versions of black + # give identical output for identical input? + + +if __name__ == "__main__": + # Run tests, including shrinking and reporting any known failures. + test_idempotent_any_syntactically_valid_python() + + # If Atheris is available, run coverage-guided fuzzing. + # (if you want only bounded fuzzing, just use `pytest fuzz.py`) + try: + import sys + + import atheris + except ImportError: + pass + else: + test = test_idempotent_any_syntactically_valid_python + atheris.Setup( + sys.argv, + test.hypothesis.fuzz_one_input, # type: ignore[attr-defined] + ) + atheris.Fuzz() diff --git a/scripts/generate_schema.py b/scripts/generate_schema.py new file mode 100755 index 0000000..a99942a --- /dev/null +++ b/scripts/generate_schema.py @@ -0,0 +1,75 @@ +import json +from typing import IO, Any + +import click + +import black + + +def generate_schema_from_click( + cmd: click.Command, +) -> dict[str, Any]: + result: dict[str, dict[str, Any]] = {} + for param in cmd.params: + if not isinstance(param, click.Option) or param.is_eager: + continue + + assert param.name + name = param.name.replace("_", "-") + + result[name] = {} + + match param.type: + case click.types.IntParamType(): + result[name]["type"] = "integer" + case click.types.StringParamType() | click.types.Path(): + result[name]["type"] = "string" + case click.types.Choice(choices=choices): + result[name]["enum"] = choices + case click.types.BoolParamType(): + result[name]["type"] = "boolean" + case _: + msg = f"{param.type!r} not a known type for {param}" + raise TypeError(msg) + + if param.multiple: + result[name] = {"type": "array", "items": result[name]} + + result[name]["description"] = param.help + + default = param.to_info_dict()["default"] + if default is not None and not param.multiple: + result[name]["default"] = default + + return result + + +@click.command(context_settings={"help_option_names": ["-h", "--help"]}) +@click.option("--schemastore", is_flag=True, help="SchemaStore format") +@click.option("--outfile", type=click.File(mode="w"), help="Write to file") +def main(schemastore: bool, outfile: IO[str]) -> None: + properties = generate_schema_from_click(black.main) + del properties["line-ranges"] + + schema: dict[str, Any] = { + "$schema": "http://json-schema.org/draft-07/schema#", + "$id": ( + "https://github.com/psf/black/blob/main/src/black/resources/black.schema.json" + ), + "$comment": "tool.black table in pyproject.toml", + "type": "object", + "additionalProperties": False, + "properties": properties, + } + + if schemastore: + schema["$id"] = "https://json.schemastore.org/partial-black.json" + # The precise list of unstable features may change frequently, so don't + # bother putting it in SchemaStore + schema["properties"]["enable-unstable-feature"]["items"] = {"type": "string"} + + print(json.dumps(schema, indent=2), file=outfile) + + +if __name__ == "__main__": + main() diff --git a/scripts/make_width_table.py b/scripts/make_width_table.py new file mode 100644 index 0000000..bf4dbd0 --- /dev/null +++ b/scripts/make_width_table.py @@ -0,0 +1,66 @@ +"""Generates a width table for Unicode characters. + +This script generates a width table for Unicode characters that are not +narrow (width 1). The table is written to src/black/_width_table.py (note +that although this file is generated, it is checked into Git) and is used +by the char_width() function in src/black/strings.py. + +You should run this script when you upgrade wcwidth, which is expected to +happen when a new Unicode version is released. The generated table contains +the version of wcwidth and Unicode that it was generated for. + +In order to run this script, you need to install the latest version of wcwidth. +You can do this by running: + + pip install --group width-table + +""" + +import sys +from collections.abc import Iterable +from os.path import basename, dirname, join + +import wcwidth # type: ignore[import-not-found] + + +def make_width_table() -> Iterable[tuple[int, int, int]]: + start_codepoint = -1 + end_codepoint = -1 + range_width = -2 + for codepoint in range(0, sys.maxunicode + 1): + width = wcwidth.wcwidth(chr(codepoint)) + if width <= 1: + # Ignore narrow characters along with zero-width characters so that + # they are treated as single-width. Note that treating zero-width + # characters as single-width is consistent with the heuristics built + # on top of str.isascii() in the str_width() function in strings.py. + continue + if start_codepoint < 0: + start_codepoint = codepoint + range_width = width + elif width != range_width or codepoint != end_codepoint + 1: + yield (start_codepoint, end_codepoint, range_width) + start_codepoint = codepoint + range_width = width + end_codepoint = codepoint + if start_codepoint >= 0: + yield (start_codepoint, end_codepoint, range_width) + + +def main() -> None: + table_path = join(dirname(__file__), "..", "src", "black", "_width_table.py") + with open(table_path, "w") as f: + f.write(f"""# Generated by {basename(__file__)} +# wcwidth {wcwidth.__version__} +# Unicode {wcwidth.list_versions()[-1]} +from typing import Final + +WIDTH_TABLE: Final[list[tuple[int, int, int]]] = [ +""") + for triple in make_width_table(): + f.write(f" {triple!r},\n") + f.write("]\n") + + +if __name__ == "__main__": + main() diff --git a/scripts/migrate-black.py b/scripts/migrate-black.py new file mode 100755 index 0000000..c8faac4 --- /dev/null +++ b/scripts/migrate-black.py @@ -0,0 +1,96 @@ +#!/usr/bin/env python3 +# check out every commit added by the current branch, blackify them, +# and generate diffs to reconstruct the original commits, but then +# blackified +import logging +import os +import sys +from subprocess import PIPE, Popen, check_output, run + + +def git(*args: str) -> str: + return check_output(["git", *args]).decode("utf8").strip() + + +def blackify(base_branch: str, black_command: str, logger: logging.Logger) -> int: + current_branch = git("branch", "--show-current") + + if not current_branch or base_branch == current_branch: + logger.error("You need to check out a feature branch to work on") + return 1 + + if not os.path.exists(".git"): + logger.error("Run me in the root of your repo") + return 1 + + merge_base = git("merge-base", "HEAD", base_branch) + if not merge_base: + logger.error( + f"Could not find a common commit for current head and {base_branch}" + ) + return 1 + + commits = git( + "log", "--reverse", "--pretty=format:%H", f"{merge_base}~1..HEAD" + ).split() + for commit in commits: + git("checkout", commit, f"-b{commit}-black") + check_output(black_command, shell=True) + git("commit", "-aqm", "blackify") + + git("checkout", base_branch, f"-b{current_branch}-black") + + for last_commit, commit in zip(commits, commits[1:], strict=False): + allow_empty = ( + b"--allow-empty" in run(["git", "apply", "-h"], stdout=PIPE).stdout + ) + quiet = b"--quiet" in run(["git", "apply", "-h"], stdout=PIPE).stdout + git_diff = Popen( + [ + "git", + "diff", + "--binary", + "--find-copies", + f"{last_commit}-black..{commit}-black", + ], + stdout=PIPE, + ) + git_apply = Popen( + [ + "git", + "apply", + ] + + (["--quiet"] if quiet else []) + + [ + "-3", + "--intent-to-add", + ] + + (["--allow-empty"] if allow_empty else []) + + [ + "-", + ], + stdin=git_diff.stdout, + ) + if git_diff.stdout is not None: + git_diff.stdout.close() + git_apply.communicate() + git("commit", "--allow-empty", "-aqC", commit) + + for commit in commits: + git("branch", "-qD", f"{commit}-black") + + return 0 + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser() + parser.add_argument("base_branch") + parser.add_argument("--black_command", default="black -q .") + parser.add_argument("--logfile", type=argparse.FileType("w"), default=sys.stdout) + args = parser.parse_args() + logger = logging.getLogger(__name__) + logger.addHandler(logging.StreamHandler(args.logfile)) + logger.setLevel(logging.INFO) + sys.exit(blackify(args.base_branch, args.black_command, logger)) diff --git a/scripts/release.py b/scripts/release.py new file mode 100755 index 0000000..0d7ffc5 --- /dev/null +++ b/scripts/release.py @@ -0,0 +1,248 @@ +#!/usr/bin/env python3 + +""" +Tool to help automate changes needed in commits during and after releases +""" + +from __future__ import annotations + +import argparse +import logging +import re +import sys +from datetime import datetime +from pathlib import Path +from subprocess import run + +LOG = logging.getLogger(__name__) +NEW_VERSION_CHANGELOG_TEMPLATE = """\ +## Unreleased + + + +### Highlights + + + +### Stable style + + + +### Preview style + + + +### Configuration + + + +### Packaging + + + +### Parser + + + +### Performance + + + +### Output + + + +### _Blackd_ + + + +### Integrations + + + +### Documentation + + +""" + + +class NoGitTagsError(Exception): ... + + +# TODO: Do better with alpha + beta releases +# Maybe we vendor packaging library +def get_git_tags(versions_only: bool = True) -> list[str]: + """Pull out all tags or calvers only""" + cp = run(["git", "tag"], capture_output=True, check=True, encoding="utf8") + if not cp.stdout: + LOG.error(f"Returned no git tags stdout: {cp.stderr}") + raise NoGitTagsError + git_tags = cp.stdout.splitlines() + if versions_only: + return [t for t in git_tags if t[0].isdigit()] + return git_tags + + +# TODO: Support sorting alpha/beta releases correctly +def tuple_calver(calver: str) -> tuple[int, ...]: # mypy can't notice maxsplit below + """Convert a calver string into a tuple of ints for sorting""" + try: + return tuple(map(int, calver.split(".", maxsplit=2))) + except ValueError: + return (0, 0, 0) + + +class SourceFiles: + def __init__(self, black_repo_dir: Path): + # File path fun all pathlib to be platform agnostic + self.black_repo_path = black_repo_dir + self.changes_path = self.black_repo_path / "CHANGES.md" + self.docs_path = self.black_repo_path / "docs" + self.version_doc_paths = ( + self.docs_path / "integrations" / "source_version_control.md", + self.docs_path / "usage_and_configuration" / "the_basics.md", + self.docs_path / "guides" / "using_black_with_jupyter_notebooks.md", + ) + self.current_version = self.get_current_version() + self.next_version = self.get_next_version() + + def __str__(self) -> str: + return f"""\ +> SourceFiles ENV: + Repo path: {self.black_repo_path} + CHANGES.md path: {self.changes_path} + docs path: {self.docs_path} + Current version: {self.current_version} + Next version: {self.next_version} +""" + + def add_template_to_changes(self) -> int: + """Add the template to CHANGES.md if it does not exist""" + LOG.info(f"Adding template to {self.changes_path}") + + with self.changes_path.open("r", encoding="utf-8") as cfp: + changes_string = cfp.read() + + if "## Unreleased" in changes_string: + LOG.error(f"{self.changes_path} already has unreleased template") + return 1 + + templated_changes_string = changes_string.replace( + "# Change Log\n", + f"# Change Log\n\n{NEW_VERSION_CHANGELOG_TEMPLATE}", + ) + + with self.changes_path.open("w", encoding="utf-8") as cfp: + cfp.write(templated_changes_string) + + LOG.info(f"Added template to {self.changes_path}") + return 0 + + def cleanup_changes_template_for_release(self) -> None: + LOG.info(f"Cleaning up {self.changes_path}") + + with self.changes_path.open("r", encoding="utf-8") as cfp: + changes_string = cfp.read() + + # Change Unreleased to next version + changes_string = changes_string.replace( + "## Unreleased", f"## Version {self.next_version}" + ) + + # Remove all comments + changes_string = re.sub(r"(?m)^)\n+", "", changes_string) + + # Remove empty subheadings + changes_string = re.sub(r"(?m)^###.+\n+(?=#)", "", changes_string) + + with self.changes_path.open("w", encoding="utf-8") as cfp: + cfp.write(changes_string) + + LOG.debug(f"Finished Cleaning up {self.changes_path}") + + def get_current_version(self) -> str: + """Get the latest git (version) tag as latest version""" + return sorted(get_git_tags(), key=lambda k: tuple_calver(k))[-1] + + def get_next_version(self) -> str: + """Workout the year and month + version number we need to move to""" + base_calver = datetime.today().strftime("%y.%m") + calver_parts = base_calver.split(".") + base_calver = f"{calver_parts[0]}.{int(calver_parts[1])}" # Remove leading 0 + git_tags = get_git_tags() + same_month_releases = [ + t for t in git_tags if t.startswith(base_calver) and "a" not in t + ] + if len(same_month_releases) < 1: + return f"{base_calver}.0" + same_month_version = same_month_releases[-1].split(".", 2)[-1] + return f"{base_calver}.{int(same_month_version) + 1}" + + def update_repo_for_release(self) -> int: + """Update CHANGES.md + doc files ready for release""" + self.cleanup_changes_template_for_release() + self.update_version_in_docs() + return 0 # return 0 if no exceptions hit + + def update_version_in_docs(self) -> None: + for doc_path in self.version_doc_paths: + LOG.info(f"Updating black version to {self.next_version} in {doc_path}") + + with doc_path.open("r", encoding="utf-8") as dfp: + doc_string = dfp.read() + + next_version_doc = doc_string.replace( + self.current_version, self.next_version + ) + + with doc_path.open("w", encoding="utf-8") as dfp: + dfp.write(next_version_doc) + + LOG.debug( + f"Finished updating black version to {self.next_version} in {doc_path}" + ) + + +def _handle_debug(debug: bool) -> None: + """Turn on debugging if asked otherwise INFO default""" + log_level = logging.DEBUG if debug else logging.INFO + logging.basicConfig( + format="[%(asctime)s] %(levelname)s: %(message)s (%(filename)s:%(lineno)d)", + level=log_level, + ) + + +def parse_args() -> argparse.Namespace: + parser = argparse.ArgumentParser() + parser.add_argument( + "-a", + "--add-changes-template", + action="store_true", + help="Add the Unreleased template to CHANGES.md", + ) + parser.add_argument( + "-d", "--debug", action="store_true", help="Verbose debug output" + ) + args = parser.parse_args() + _handle_debug(args.debug) + return args + + +def main() -> int: + args = parse_args() + + # Need parent.parent cause script is in scripts/ directory + sf = SourceFiles(Path(__file__).parent.parent) + + if args.add_changes_template: + return sf.add_template_to_changes() + + LOG.info(f"Current version detected to be {sf.current_version}") + LOG.info(f"Next version will be {sf.next_version}") + return sf.update_repo_for_release() + + +if __name__ == "__main__": # pragma: no cover + sys.exit(main()) diff --git a/scripts/release_tests.py b/scripts/release_tests.py new file mode 100644 index 0000000..ffd4a35 --- /dev/null +++ b/scripts/release_tests.py @@ -0,0 +1,69 @@ +#!/usr/bin/env python3 + +import unittest +from pathlib import Path +from shutil import rmtree +from tempfile import TemporaryDirectory +from typing import Any +from unittest.mock import Mock, patch + +from release import SourceFiles, tuple_calver # type: ignore + + +class FakeDateTime: + """Used to mock the date to test generating next calver function""" + + def today(*args: Any, **kwargs: Any) -> "FakeDateTime": # noqa: B902 + return FakeDateTime() + + # Add leading 0 on purpose to ensure we remove it + def strftime(*args: Any, **kwargs: Any) -> str: # noqa: B902 + return "69.01" + + +class TestRelease(unittest.TestCase): + def setUp(self) -> None: + # We only test on >= 3.12 + self.tempdir = TemporaryDirectory(delete=False) # type: ignore + self.tempdir_path = Path(self.tempdir.name) + self.sf = SourceFiles(self.tempdir_path) + + def tearDown(self) -> None: + rmtree(self.tempdir.name) + return super().tearDown() + + @patch("release.get_git_tags") + def test_get_current_version(self, mocked_git_tags: Mock) -> None: + mocked_git_tags.return_value = ["1.1.0", "69.1.0", "69.1.1", "2.2.0"] + self.assertEqual("69.1.1", self.sf.get_current_version()) + + @patch("release.get_git_tags") + @patch("release.datetime", FakeDateTime) + def test_get_next_version(self, mocked_git_tags: Mock) -> None: + # test we handle no args + mocked_git_tags.return_value = [] + self.assertEqual( + "69.1.0", + self.sf.get_next_version(), + "Unable to get correct next version with no git tags", + ) + + # test we handle + mocked_git_tags.return_value = ["1.1.0", "69.1.0", "69.1.1", "2.2.0"] + self.assertEqual( + "69.1.2", + self.sf.get_next_version(), + "Unable to get correct version with 2 previous versions released this" + " month", + ) + + def test_tuple_calver(self) -> None: + first_month_release = tuple_calver("69.1.0") + second_month_release = tuple_calver("69.1.1") + self.assertEqual((69, 1, 0), first_month_release) + self.assertEqual((0, 0, 0), tuple_calver("69.1.1a0")) # Hack for alphas/betas + self.assertTrue(first_month_release < second_month_release) + + +if __name__ == "__main__": + unittest.main() diff --git a/src/_black_version.pyi b/src/_black_version.pyi new file mode 100644 index 0000000..c2ee2ca --- /dev/null +++ b/src/_black_version.pyi @@ -0,0 +1 @@ +version: str diff --git a/src/black/__init__.py b/src/black/__init__.py new file mode 100644 index 0000000..14e5770 --- /dev/null +++ b/src/black/__init__.py @@ -0,0 +1,1722 @@ +import io +import json +import platform +import re +import sys +import tokenize +import traceback +from collections.abc import ( + Collection, + Generator, + MutableMapping, + Sequence, +) +from contextlib import nullcontext +from dataclasses import replace +from datetime import datetime, timezone +from enum import Enum +from json.decoder import JSONDecodeError +from pathlib import Path +from re import Pattern +from typing import Any + +import click +from click.core import ParameterSource +from mypy_extensions import mypyc_attr +from pathspec import GitIgnoreSpec +from pathspec.patterns.gitignore import GitIgnorePatternError + +from _black_version import version as __version__ +from black.cache import Cache +from black.comments import normalize_fmt_off +from black.const import ( + DEFAULT_EXCLUDES, + DEFAULT_INCLUDES, + DEFAULT_LINE_LENGTH, + STDIN_PLACEHOLDER, +) +from black.files import ( + best_effort_relative_path, + find_project_root, + find_pyproject_toml, + find_user_pyproject_toml, + gen_python_files, + get_gitignore, + parse_pyproject_toml, + path_is_excluded, + resolves_outside_root_or_cannot_stat, + wrap_stream_for_windows, +) +from black.handle_ipynb_magics import ( + PYTHON_CELL_MAGICS, + jupyter_dependencies_are_installed, + mask_cell, + put_trailing_semicolon_back, + remove_trailing_semicolon, + unmask_cell, + validate_cell, +) +from black.linegen import LN, LineGenerator, transform_line +from black.lines import EmptyLineTracker, LinesBlock +from black.mode import FUTURE_FLAG_TO_FEATURE, VERSION_TO_FEATURES, Feature +from black.mode import Mode as Mode # re-exported +from black.mode import Preview, TargetVersion, supports_feature +from black.nodes import STARS, is_number_token, is_simple_decorator_expression, syms +from black.output import color_diff, diff, dump_to_file, err, ipynb_diff, out +from black.parsing import ( # noqa F401 + ASTSafetyError, + InvalidInput, + SourceASTParseError, + lib2to3_parse, + parse_ast, + stringify_ast, +) +from black.ranges import ( + adjusted_lines, + convert_unchanged_lines, + parse_line_ranges, + sanitized_lines, +) +from black.report import Changed, NothingChanged, Report +from blib2to3.pgen2 import token +from blib2to3.pytree import Leaf, Node + +COMPILED = Path(__file__).suffix in (".pyd", ".so") + +# types +FileContent = str +Encoding = str +NewLine = str + + +class WriteBack(Enum): + NO = 0 + YES = 1 + DIFF = 2 + CHECK = 3 + COLOR_DIFF = 4 + + @classmethod + def from_configuration( + cls, *, check: bool, diff: bool, color: bool = False + ) -> "WriteBack": + if check and not diff: + return cls.CHECK + + if diff and color: + return cls.COLOR_DIFF + + return cls.DIFF if diff else cls.YES + + +# Legacy name, left for integrations. +FileMode = Mode + + +def read_pyproject_toml( + ctx: click.Context, param: click.Parameter | None, value: str | None +) -> str | None: + """Inject Black configuration from "pyproject.toml" into defaults in `ctx`. + + Returns the path to a successfully found and read configuration file, None + otherwise. + """ + if not value: + value = find_pyproject_toml( + ctx.params.get("src", ()), ctx.params.get("stdin_filename", None) + ) + if value is None: + return None + + try: + config = parse_pyproject_toml(value) + except (OSError, ValueError) as e: + raise click.FileError( + filename=value, hint=f"Error reading configuration file: {e}" + ) from None + + if not config: + return None + else: + spellcheck_pyproject_toml_keys(ctx, list(config), value) + # Sanitize the values to be Click friendly. For more information please see: + # https://github.com/psf/black/issues/1458 + # https://github.com/pallets/click/issues/1567 + config = { + k: str(v) if not isinstance(v, (list, dict)) else v + for k, v in config.items() + } + + target_version = config.get("target_version") + if target_version is not None and not isinstance(target_version, list): + raise click.BadOptionUsage( + "target-version", "Config key target-version must be a list" + ) + + exclude = config.get("exclude") + if exclude is not None and not isinstance(exclude, str): + raise click.BadOptionUsage("exclude", "Config key exclude must be a string") + + include = config.get("include") + if include is not None and not isinstance(include, str): + raise click.BadOptionUsage("include", "Config key include must be a string") + + extend_exclude = config.get("extend_exclude") + if extend_exclude is not None and not isinstance(extend_exclude, str): + raise click.BadOptionUsage( + "extend-exclude", "Config key extend-exclude must be a string" + ) + + force_exclude = config.get("force_exclude") + if force_exclude is not None and not isinstance(force_exclude, str): + raise click.BadOptionUsage( + "force-exclude", "Config key force-exclude must be a string" + ) + + line_ranges = config.get("line_ranges") + if line_ranges is not None: + raise click.BadOptionUsage( + "line-ranges", "Cannot use line-ranges in the pyproject.toml file." + ) + + default_map: dict[str, Any] = {} + if ctx.default_map: + default_map.update(ctx.default_map) + default_map.update(config) + + ctx.default_map = default_map + return value + + +def spellcheck_pyproject_toml_keys( + ctx: click.Context, config_keys: list[str], config_file_path: str +) -> None: + invalid_keys: list[str] = [] + available_config_options = {param.name for param in ctx.command.params} + invalid_keys = [key for key in config_keys if key not in available_config_options] + if invalid_keys: + keys_str = ", ".join(map(repr, invalid_keys)) + out( + f"Invalid config keys detected: {keys_str} (in {config_file_path})", + fg="red", + ) + + +def target_version_option_callback( + c: click.Context, p: click.Option | click.Parameter, v: tuple[str, ...] +) -> list[TargetVersion]: + """Compute the target versions from a --target-version flag. + + This is its own function because mypy couldn't infer the type correctly + when it was a lambda, causing mypyc trouble. + """ + return [TargetVersion[val.upper()] for val in v] + + +def _target_versions_exceed_runtime( + target_versions: set[TargetVersion], +) -> bool: + """Check if ALL target versions exceed the runtime Python version. + + If any target version is at or below the runtime version, the AST + safety check can succeed for that version's features, so the warning + would be spurious. + """ + if not target_versions: + return False + min_target_minor = min(tv.value for tv in target_versions) + return min_target_minor > sys.version_info[1] + + +def _version_mismatch_message(target_versions: set[TargetVersion]) -> str: + max_target = max(target_versions, key=lambda tv: tv.value) + runtime = f"{sys.version_info[0]}.{sys.version_info[1]}" + return ( + f"Python {runtime} cannot parse code formatted for" + f" {max_target.pretty()}. To fix this: run Black with" + f" {max_target.pretty()}, set --target-version to" + f" py3{sys.version_info[1]}, or use --fast to skip the safety" + " check." + ) + + +def enable_unstable_feature_callback( + c: click.Context, p: click.Option | click.Parameter, v: tuple[str, ...] +) -> list[Preview]: + """Compute the features from an --enable-unstable-feature flag.""" + return [Preview[val] for val in v] + + +def re_compile_maybe_verbose(regex: str) -> Pattern[str]: + """Compile a regular expression string in `regex`. + + If it contains newlines, use verbose mode. + """ + if "\n" in regex: + regex = "(?x)" + regex + compiled: Pattern[str] = re.compile(regex) + return compiled + + +def validate_regex( + ctx: click.Context, + param: click.Parameter, + value: str | None, +) -> Pattern[str] | None: + try: + return re_compile_maybe_verbose(value) if value is not None else None + except re.error as e: + raise click.BadParameter(f"Not a valid regular expression: {e}") from None + + +@click.command( + context_settings={"help_option_names": ["-h", "--help"]}, + # While Click does set this field automatically using the docstring, mypyc + # (annoyingly) strips 'em so we need to set it here too. + help="The uncompromising code formatter.", +) +@click.option("-c", "--code", type=str, help="Format the code passed in as a string.") +@click.option( + "-l", + "--line-length", + type=int, + default=DEFAULT_LINE_LENGTH, + help="How many characters per line to allow.", + show_default=True, +) +@click.option( + "-t", + "--target-version", + type=click.Choice([v.name.lower() for v in TargetVersion]), + callback=target_version_option_callback, + multiple=True, + help=( + "Python versions that should be supported by Black's output. You should" + " include all versions that your code supports. By default, Black will infer" + " target versions from the project metadata in pyproject.toml. If this does" + " not yield conclusive results, Black will use per-file auto-detection." + ), +) +@click.option( + "--pyi", + is_flag=True, + help=( + "Format all input files like typing stubs regardless of file extension. This" + " is useful when piping source on standard input." + ), +) +@click.option( + "--ipynb", + is_flag=True, + help=( + "Format all input files like Jupyter Notebooks regardless of file extension." + " This is useful when piping source on standard input." + ), +) +@click.option( + "--python-cell-magics", + multiple=True, + help=( + "When processing Jupyter Notebooks, add the given magic to the list" + f" of known python-magics ({', '.join(sorted(PYTHON_CELL_MAGICS))})." + " Useful for formatting cells with custom python magics." + ), + default=[], +) +@click.option( + "-x", + "--skip-source-first-line", + is_flag=True, + help="Skip the first line of the source code.", +) +@click.option( + "-S", + "--skip-string-normalization", + is_flag=True, + help="Don't normalize string quotes or prefixes.", +) +@click.option( + "-C", + "--skip-magic-trailing-comma", + is_flag=True, + help="Don't use trailing commas as a reason to split lines.", +) +@click.option( + "--preview", + is_flag=True, + help=( + "Enable potentially disruptive style changes that may be added to Black's main" + " functionality in the next major release." + ), +) +@click.option( + "--unstable", + is_flag=True, + help=( + "Enable potentially disruptive style changes that have known bugs or are not" + " currently expected to make it into the stable style Black's next major" + " release. Implies --preview." + ), +) +@click.option( + "--enable-unstable-feature", + type=click.Choice([v.name for v in Preview]), + callback=enable_unstable_feature_callback, + multiple=True, + help=( + "Enable specific features included in the `--unstable` style. Requires" + " `--preview`. No compatibility guarantees are provided on the behavior" + " or existence of any unstable features." + ), +) +@click.option( + "--check", + is_flag=True, + help=( + "Don't write the files back, just return the status. Return code 0 means" + " nothing would change. Return code 1 means some files would be reformatted." + " Return code 123 means there was an internal error." + ), +) +@click.option( + "--diff", + is_flag=True, + help=( + "Don't write the files back, just output a diff to indicate what changes" + " Black would've made. They are printed to stdout so capturing them is simple." + ), +) +@click.option( + "--color/--no-color", + is_flag=True, + help="Show (or do not show) colored diff. Only applies when --diff is given.", +) +@click.option( + "--line-ranges", + multiple=True, + metavar="START-END", + help=( + "When specified, Black will try its best to only format these lines. This" + " option can be specified multiple times, and a union of the lines will be" + " formatted. Each range must be specified as two integers connected by a `-`:" + " `-`. The `` and `` integer indices are 1-based and" + " inclusive on both ends." + ), + default=(), +) +@click.option( + "--fast/--safe", + is_flag=True, + help=( + "By default, Black performs an AST safety check after formatting your code." + " The --fast flag turns off this check and the --safe flag explicitly enables" + " it. [default: --safe]" + ), +) +@click.option( + "--required-version", + type=str, + help=( + "Require a specific version of Black to be running. This is useful for" + " ensuring that all contributors to your project are using the same" + " version, because different versions of Black may format code a little" + " differently. This option can be set in a configuration file for consistent" + " results across environments." + ), +) +@click.option( + "--exclude", + type=str, + callback=validate_regex, + help=( + "A regular expression that matches files and directories that should be" + " excluded on recursive searches. An empty value means no paths are excluded." + " Use forward slashes for directories on all platforms (Windows, too)." + " By default, Black also ignores all paths listed in .gitignore. Changing this" + f" value will override all default exclusions. [default: {DEFAULT_EXCLUDES}]" + ), + show_default=False, +) +@click.option( + "--extend-exclude", + type=str, + callback=validate_regex, + help=( + "Like --exclude, but adds additional files and directories on top of the" + " default values instead of overriding them." + ), +) +@click.option( + "--force-exclude", + type=str, + callback=validate_regex, + help=( + "Like --exclude, but files and directories matching this regex will be excluded" + " even when they are passed explicitly as arguments. This is useful when" + " invoking Black programmatically on changed files, such as in a pre-commit" + " hook or editor plugin." + ), +) +@click.option( + "--stdin-filename", + type=str, + is_eager=True, + help=( + "The name of the file when passing it through stdin. Useful to make sure Black" + " will respect the --force-exclude option on some editors that rely on using" + " stdin." + ), +) +@click.option( + "--include", + type=str, + default=DEFAULT_INCLUDES, + callback=validate_regex, + help=( + "A regular expression that matches files and directories that should be" + " included on recursive searches. An empty value means all files are included" + " regardless of the name. Use forward slashes for directories on all platforms" + " (Windows, too). Overrides all exclusions, including from .gitignore and" + " command line options." + ), + show_default=True, +) +@click.option( + "-W", + "--workers", + type=click.IntRange(min=1), + default=None, + help=( + "When Black formats multiple files, it may use a process pool to speed up" + " formatting. This option controls the number of parallel workers. This can" + " also be specified via the BLACK_NUM_WORKERS environment variable. Defaults" + " to the number of CPUs in the system." + ), +) +@click.option( + "-q", + "--quiet", + is_flag=True, + help=( + "Stop emitting all non-critical output. Error messages will still be emitted" + " (which can silenced by 2>/dev/null)." + ), +) +@click.option( + "-v", + "--verbose", + is_flag=True, + help=( + "Emit messages about files that were not changed or were ignored due to" + " exclusion patterns. If Black is using a configuration file, a message" + " detailing which one it is using will be emitted." + ), +) +@click.version_option( + version=__version__, + message=( + f"%(prog)s, %(version)s (compiled: {'yes' if COMPILED else 'no'})\n" + f"Python ({platform.python_implementation()}) {platform.python_version()}" + ), +) +@click.argument( + "src", + nargs=-1, + type=click.Path( + exists=True, file_okay=True, dir_okay=True, readable=True, allow_dash=True + ), + is_eager=True, + metavar="SRC ...", +) +@click.option( + "--config", + type=click.Path( + exists=True, + file_okay=True, + dir_okay=False, + readable=True, + allow_dash=False, + path_type=str, + ), + is_eager=True, + callback=read_pyproject_toml, + help="Read configuration options from a configuration file.", +) +@click.option( + "--no-cache", + is_flag=True, + help=( + "Skip reading and writing the cache, forcing Black to reformat all" + " included files." + ), +) +@click.pass_context +def main( + ctx: click.Context, + code: str | None, + line_length: int, + target_version: list[TargetVersion], + check: bool, + diff: bool, + line_ranges: Sequence[str], + color: bool, + fast: bool, + pyi: bool, + ipynb: bool, + python_cell_magics: Sequence[str], + skip_source_first_line: bool, + skip_string_normalization: bool, + skip_magic_trailing_comma: bool, + preview: bool, + unstable: bool, + enable_unstable_feature: list[Preview], + quiet: bool, + verbose: bool, + required_version: str | None, + include: Pattern[str], + exclude: Pattern[str] | None, + extend_exclude: Pattern[str] | None, + force_exclude: Pattern[str] | None, + stdin_filename: str | None, + workers: int | None, + src: tuple[str, ...], + config: str | None, + no_cache: bool, +) -> None: + """The uncompromising code formatter.""" + ctx.ensure_object(dict) + + assert sys.version_info >= (3, 10), "Black requires Python 3.10+" + if sys.version_info[:3] == (3, 12, 5): + out( + "Python 3.12.5 has a memory safety issue that can cause Black's " + "AST safety checks to fail. " + "Please upgrade to Python 3.12.6 or downgrade to Python 3.12.4" + ) + ctx.exit(1) + + if src and code is not None: + out( + main.get_usage(ctx) + + "\n\n'SRC' and 'code' cannot be passed simultaneously." + ) + ctx.exit(1) + if not src and code is None: + out(main.get_usage(ctx) + "\n\nOne of 'SRC' or 'code' is required.") + ctx.exit(1) + + # It doesn't do anything if --unstable is also passed, so just allow it. + if enable_unstable_feature and not (preview or unstable): + out( + main.get_usage(ctx) + + "\n\n'--enable-unstable-feature' requires '--preview'." + ) + ctx.exit(1) + + root, method = ( + find_project_root(src, stdin_filename) if code is None else (None, None) + ) + ctx.obj["root"] = root + + if verbose: + if root: + out( + f"Identified `{root}` as project root containing a {method}.", + fg="blue", + ) + + if config: + config_source = ctx.get_parameter_source("config") + user_level_config = str(find_user_pyproject_toml()) + if config == user_level_config: + out( + "Using configuration from user-level config at " + f"'{user_level_config}'.", + fg="blue", + ) + elif config_source in ( + ParameterSource.DEFAULT, + ParameterSource.DEFAULT_MAP, + ): + out("Using configuration from project root.", fg="blue") + else: + out(f"Using configuration in '{config}'.", fg="blue") + if ctx.default_map: + for param, value in ctx.default_map.items(): + out(f"{param}: {value}") + + error_msg = "Oh no! 💥 💔 💥" + if ( + required_version + and required_version != __version__ + and required_version != __version__.split(".")[0] + ): + err( + f"{error_msg} The required version `{required_version}` does not match" + f" the running version `{__version__}`!" + ) + ctx.exit(1) + if ipynb and pyi: + err("Cannot pass both `pyi` and `ipynb` flags!") + ctx.exit(1) + + write_back = WriteBack.from_configuration(check=check, diff=diff, color=color) + if target_version: + versions = set(target_version) + else: + # We'll autodetect later. + versions = set() + mode = Mode( + target_versions=versions, + line_length=line_length, + is_pyi=pyi, + is_ipynb=ipynb, + skip_source_first_line=skip_source_first_line, + string_normalization=not skip_string_normalization, + magic_trailing_comma=not skip_magic_trailing_comma, + preview=preview, + unstable=unstable, + python_cell_magics=set(python_cell_magics), + enabled_features=set(enable_unstable_feature), + ) + + if not fast and _target_versions_exceed_runtime(versions): + err( + f"Warning: {_version_mismatch_message(versions)} Black's safety" + " check verifies equivalence by parsing the AST, which fails" + " when the running Python is older than the target version.", + fg="yellow", + ) + + lines: list[tuple[int, int]] = [] + if line_ranges: + if ipynb: + err("Cannot use --line-ranges with ipynb files.") + ctx.exit(1) + + try: + lines = parse_line_ranges(line_ranges) + except ValueError as e: + err(str(e)) + ctx.exit(1) + + if code is not None: + # Run in quiet mode by default with -c; the extra output isn't useful. + # You can still pass -v to get verbose output. + quiet = True + + report = Report(check=check, diff=diff, quiet=quiet, verbose=verbose) + + if code is not None: + reformat_code( + content=code, + fast=fast, + write_back=write_back, + mode=mode, + report=report, + lines=lines, + ) + else: + assert root is not None # root is only None if code is not None + try: + sources = get_sources( + root=root, + src=src, + quiet=quiet, + verbose=verbose, + include=include, + exclude=exclude, + extend_exclude=extend_exclude, + force_exclude=force_exclude, + report=report, + stdin_filename=stdin_filename, + ) + except GitIgnorePatternError: + ctx.exit(1) + + if not sources: + if verbose or not quiet: + out("No Python files are present to be formatted. Nothing to do 😴") + if "-" in src: + sys.stdout.write(sys.stdin.read()) + ctx.exit(0) + + if len(sources) == 1: + reformat_one( + src=sources.pop(), + fast=fast, + write_back=write_back, + mode=mode, + report=report, + lines=lines, + no_cache=no_cache, + ) + else: + from black.concurrency import reformat_many + + if lines: + err("Cannot use --line-ranges to format multiple files.") + ctx.exit(1) + reformat_many( + sources=sources, + fast=fast, + write_back=write_back, + mode=mode, + report=report, + workers=workers, + no_cache=no_cache, + ) + + if verbose or not quiet: + if code is None and (verbose or report.change_count or report.failure_count): + out() + out(error_msg if report.return_code else "All done! ✨ 🍰 ✨") + if code is None: + click.echo(str(report), err=True) + ctx.exit(report.return_code) + + +def get_sources( + *, + root: Path, + src: tuple[str, ...], + quiet: bool, + verbose: bool, + include: Pattern[str], + exclude: Pattern[str] | None, + extend_exclude: Pattern[str] | None, + force_exclude: Pattern[str] | None, + report: "Report", + stdin_filename: str | None, +) -> set[Path]: + """Compute the set of files to be formatted.""" + sources: set[Path] = set() + + assert root.is_absolute(), f"INTERNAL ERROR: `root` must be absolute but is {root}" + using_default_exclude = exclude is None + exclude = re_compile_maybe_verbose(DEFAULT_EXCLUDES) if exclude is None else exclude + gitignore: dict[Path, GitIgnoreSpec] | None = None + root_gitignore = get_gitignore(root) + + for s in src: + if s == "-" and stdin_filename: + path = Path(stdin_filename) + if path_is_excluded(stdin_filename, force_exclude): + report.path_ignored( + path, + "--stdin-filename matches the --force-exclude regular expression", + ) + continue + is_stdin = True + else: + path = Path(s) + is_stdin = False + + # Compare the logic here to the logic in `gen_python_files`. + if is_stdin or path.is_file(): + if resolves_outside_root_or_cannot_stat(path, root, report): + if verbose: + out(f'Skipping invalid source: "{path}"', fg="red") + continue + + root_relative_path = best_effort_relative_path(path, root).as_posix() + root_relative_path = "/" + root_relative_path + + # Hard-exclude any files that matches the `--force-exclude` regex. + if path_is_excluded(root_relative_path, force_exclude): + report.path_ignored( + path, "matches the --force-exclude regular expression" + ) + continue + + if is_stdin: + path = Path(f"{STDIN_PLACEHOLDER}{path}") + + if path.suffix == ".ipynb" and not jupyter_dependencies_are_installed( + warn=verbose or not quiet + ): + continue + + if verbose: + out(f'Found input source: "{path}"', fg="blue") + sources.add(path) + elif path.is_dir(): + path = root / (path.resolve().relative_to(root)) + if verbose: + out(f'Found input source directory: "{path}"', fg="blue") + + if using_default_exclude: + gitignore = { + root: root_gitignore, + path: get_gitignore(path), + } + sources.update( + gen_python_files( + path.iterdir(), + root, + include, + exclude, + extend_exclude, + force_exclude, + report, + gitignore, + verbose=verbose, + quiet=quiet, + ) + ) + elif s == "-": + if verbose: + out("Found input source stdin", fg="blue") + sources.add(path) + else: + err(f"invalid path: {s}") + + return sources + + +def reformat_code( + content: str, + fast: bool, + write_back: WriteBack, + mode: Mode, + report: Report, + *, + lines: Collection[tuple[int, int]] = (), +) -> None: + """ + Reformat and print out `content` without spawning child processes. + Similar to `reformat_one`, but for string content. + + `fast`, `write_back`, and `mode` options are passed to + :func:`format_file_in_place` or :func:`format_stdin_to_stdout`. + """ + path = Path("") + try: + changed = Changed.NO + if format_stdin_to_stdout( + content=content, fast=fast, write_back=write_back, mode=mode, lines=lines + ): + changed = Changed.YES + report.done(path, changed) + except Exception as exc: + if report.verbose: + traceback.print_exc() + report.failed(path, str(exc)) + + +# diff-shades depends on being to monkeypatch this function to operate. I know it's +# not ideal, but this shouldn't cause any issues ... hopefully. ~ichard26 +@mypyc_attr(patchable=True) +def reformat_one( + src: Path, + fast: bool, + write_back: WriteBack, + mode: Mode, + report: "Report", + *, + lines: Collection[tuple[int, int]] = (), + no_cache: bool = False, +) -> None: + """Reformat a single file under `src` without spawning child processes. + + `fast`, `write_back`, and `mode` options are passed to + :func:`format_file_in_place` or :func:`format_stdin_to_stdout`. + """ + try: + changed = Changed.NO + + if str(src) == "-": + is_stdin = True + elif str(src).startswith(STDIN_PLACEHOLDER): + is_stdin = True + # Use the original name again in case we want to print something + # to the user + src = Path(str(src)[len(STDIN_PLACEHOLDER) :]) + else: + is_stdin = False + + if is_stdin: + if src.suffix == ".pyi": + mode = replace(mode, is_pyi=True) + elif src.suffix == ".ipynb": + mode = replace(mode, is_ipynb=True) + if format_stdin_to_stdout( + fast=fast, write_back=write_back, mode=mode, lines=lines + ): + changed = Changed.YES + else: + cache = None if no_cache else Cache.read(mode) + if cache is not None and write_back not in ( + WriteBack.DIFF, + WriteBack.COLOR_DIFF, + ): + if not cache.is_changed(src): + changed = Changed.CACHED + if changed is not Changed.CACHED and format_file_in_place( + src, fast=fast, write_back=write_back, mode=mode, lines=lines + ): + changed = Changed.YES + if cache is not None and ( + (write_back is WriteBack.YES and changed is not Changed.CACHED) + or (write_back is WriteBack.CHECK and changed is Changed.NO) + ): + cache.write([src]) + report.done(src, changed) + except Exception as exc: + if report.verbose: + traceback.print_exc() + report.failed(src, str(exc)) + + +def format_file_in_place( + src: Path, + fast: bool, + mode: Mode, + write_back: WriteBack = WriteBack.NO, + lock: Any = None, # multiprocessing.Manager().Lock() is some crazy proxy + *, + lines: Collection[tuple[int, int]] = (), +) -> bool: + """Format file under `src` path. Return True if changed. + + If `write_back` is DIFF, write a diff to stdout. If it is YES, write reformatted + code to the file. + `mode` and `fast` options are passed to :func:`format_file_contents`. + """ + if src.suffix == ".pyi": + mode = replace(mode, is_pyi=True) + elif src.suffix == ".ipynb": + mode = replace(mode, is_ipynb=True) + + then = datetime.fromtimestamp(src.stat().st_mtime, timezone.utc) + header = b"" + with open(src, "rb") as buf: + if mode.skip_source_first_line: + header = buf.readline() + src_contents, encoding, newline = decode_bytes(buf.read(), mode) + try: + dst_contents = format_file_contents( + src_contents, fast=fast, mode=mode, lines=lines + ) + except NothingChanged: + return False + except JSONDecodeError: + raise ValueError( + f"File '{src}' cannot be parsed as valid Jupyter notebook." + ) from None + src_contents = header.decode(encoding) + src_contents + dst_contents = header.decode(encoding) + dst_contents + + if write_back == WriteBack.YES: + with open(src, "w", encoding=encoding, newline=newline) as f: + f.write(dst_contents) + elif write_back in (WriteBack.DIFF, WriteBack.COLOR_DIFF): + now = datetime.now(timezone.utc) + src_name = f"{src}\t{then}" + dst_name = f"{src}\t{now}" + if mode.is_ipynb: + diff_contents = ipynb_diff(src_contents, dst_contents, src_name, dst_name) + else: + diff_contents = diff(src_contents, dst_contents, src_name, dst_name) + + if write_back == WriteBack.COLOR_DIFF: + diff_contents = color_diff(diff_contents) + + with lock or nullcontext(): + f = io.TextIOWrapper( + sys.stdout.buffer, + encoding=encoding, + newline=newline, + write_through=True, + ) + f = wrap_stream_for_windows(f) + f.write(diff_contents) + f.detach() + + return True + + +def format_stdin_to_stdout( + fast: bool, + *, + content: str | None = None, + write_back: WriteBack = WriteBack.NO, + mode: Mode, + lines: Collection[tuple[int, int]] = (), +) -> bool: + """Format file on stdin. Return True if changed. + + If content is None, it's read from sys.stdin. + + If `write_back` is YES, write reformatted code back to stdout. If it is DIFF, + write a diff to stdout. The `mode` argument is passed to + :func:`format_file_contents`. + """ + then = datetime.now(timezone.utc) + + if content is None: + src, encoding, newline = decode_bytes(sys.stdin.buffer.read(), mode) + else: + src, encoding, newline = content, "utf-8", "\n" + + dst = src + try: + dst = format_file_contents(src, fast=fast, mode=mode, lines=lines) + return True + + except NothingChanged: + return False + + finally: + f = io.TextIOWrapper( + sys.stdout.buffer, encoding=encoding, newline=newline, write_through=True + ) + if write_back == WriteBack.YES: + # Make sure there's a newline after the content + if dst and dst[-1] != "\n" and dst[-1] != "\r": + dst += newline + f.write(dst) + elif write_back in (WriteBack.DIFF, WriteBack.COLOR_DIFF): + now = datetime.now(timezone.utc) + src_name = f"STDIN\t{then}" + dst_name = f"STDOUT\t{now}" + d = diff(src, dst, src_name, dst_name) + if write_back == WriteBack.COLOR_DIFF: + d = color_diff(d) + f = wrap_stream_for_windows(f) + f.write(d) + f.detach() + + +def check_stability_and_equivalence( + src_contents: str, + dst_contents: str, + *, + mode: Mode, + lines: Collection[tuple[int, int]] = (), +) -> None: + """Perform stability and equivalence checks. + + Raise AssertionError if source and destination contents are not + equivalent, or if a second pass of the formatter would format the + content differently. + """ + try: + assert_equivalent(src_contents, dst_contents) + except SourceASTParseError: + raise + except ASTSafetyError: + if _target_versions_exceed_runtime(mode.target_versions): + raise ASTSafetyError( + "failed to verify equivalence of the formatted output:" + f" {_version_mismatch_message(mode.target_versions)}" + ) from None + raise + assert_stable(src_contents, dst_contents, mode=mode, lines=lines) + + +def format_file_contents( + src_contents: str, + *, + fast: bool, + mode: Mode, + lines: Collection[tuple[int, int]] = (), +) -> FileContent: + """Reformat contents of a file and return new contents. + + If `fast` is False, additionally confirm that the reformatted code is + valid by calling :func:`assert_equivalent` and :func:`assert_stable` on it. + `mode` is passed to :func:`format_str`. + """ + if mode.is_ipynb: + dst_contents = format_ipynb_string(src_contents, fast=fast, mode=mode) + else: + dst_contents = format_str(src_contents, mode=mode, lines=lines) + if src_contents == dst_contents: + raise NothingChanged + + if not fast and not mode.is_ipynb: + # Jupyter notebooks will already have been checked above. + check_stability_and_equivalence( + src_contents, dst_contents, mode=mode, lines=lines + ) + return dst_contents + + +def format_cell(src: str, *, fast: bool, mode: Mode) -> str: + """Format code in given cell of Jupyter notebook. + + General idea is: + + - if cell has trailing semicolon, remove it; + - if cell has IPython magics, mask them; + - format cell; + - reinstate IPython magics; + - reinstate trailing semicolon (if originally present); + - strip trailing newlines. + + Cells with syntax errors will not be processed, as they + could potentially be automagics or multi-line magics, which + are currently not supported. + """ + validate_cell(src, mode) + src_without_trailing_semicolon, has_trailing_semicolon = remove_trailing_semicolon( + src + ) + try: + masked_src, replacements = mask_cell(src_without_trailing_semicolon) + except SyntaxError: + raise NothingChanged from None + masked_dst = format_str(masked_src, mode=mode) + if not fast: + check_stability_and_equivalence(masked_src, masked_dst, mode=mode) + dst_without_trailing_semicolon = unmask_cell(masked_dst, replacements) + dst = put_trailing_semicolon_back( + dst_without_trailing_semicolon, has_trailing_semicolon + ) + dst = dst.rstrip("\n") + if dst == src: + raise NothingChanged from None + return dst + + +def validate_metadata(nb: MutableMapping[str, Any]) -> None: + """If notebook is marked as non-Python, don't format it. + + All notebook metadata fields are optional, see + https://nbformat.readthedocs.io/en/stable/format_description.html. So + if a notebook has empty metadata, we will try to parse it anyway. + """ + language = nb.get("metadata", {}).get("language_info", {}).get("name", None) + if language is not None and language != "python": + raise NothingChanged from None + + +def format_ipynb_string(src_contents: str, *, fast: bool, mode: Mode) -> FileContent: + """Format Jupyter notebook. + + Operate cell-by-cell, only on code cells, only for Python notebooks. + If the ``.ipynb`` originally had a trailing newline, it'll be preserved. + """ + if not src_contents: + raise NothingChanged + + trailing_newline = src_contents[-1] == "\n" + modified = False + nb = json.loads(src_contents) + validate_metadata(nb) + for cell in nb["cells"]: + if cell.get("cell_type", None) == "code": + try: + src = "".join(cell["source"]) + dst = format_cell(src, fast=fast, mode=mode) + except NothingChanged: + pass + else: + cell["source"] = dst.splitlines(keepends=True) + modified = True + if modified: + dst_contents = json.dumps(nb, indent=1, ensure_ascii=False) + if trailing_newline: + dst_contents = dst_contents + "\n" + return dst_contents + else: + raise NothingChanged + + +def format_str( + src_contents: str, *, mode: Mode, lines: Collection[tuple[int, int]] = () +) -> str: + """Reformat a string and return new contents. + + `mode` determines formatting options, such as how many characters per line are + allowed. Example: + + >>> import black + >>> print(black.format_str("def f(arg:str='')->None:...", mode=black.Mode())) + def f(arg: str = "") -> None: + ... + + A more complex example: + + >>> print( + ... black.format_str( + ... "def f(arg:str='')->None: hey", + ... mode=black.Mode( + ... target_versions={black.TargetVersion.PY36}, + ... line_length=10, + ... string_normalization=False, + ... is_pyi=False, + ... ), + ... ), + ... ) + def f( + arg: str = '', + ) -> None: + hey + + """ + if lines: + lines = sanitized_lines(lines, src_contents) + if not lines: + return src_contents # Nothing to format + dst_contents = _format_str_once(src_contents, mode=mode, lines=lines) + # Forced second pass to work around optional trailing commas (becoming + # forced trailing commas on pass 2) interacting differently with optional + # parentheses. Admittedly ugly. + if src_contents != dst_contents: + if lines: + lines = adjusted_lines(lines, src_contents, dst_contents) + return _format_str_once(dst_contents, mode=mode, lines=lines) + return dst_contents + + +def _format_str_once( + src_contents: str, *, mode: Mode, lines: Collection[tuple[int, int]] = () +) -> str: + # Use the encoding overwrite since the src_contents may contain a different + # magic encoding comment than utf-8 + normalized_contents, _, newline_type = decode_bytes( + src_contents.encode("utf-8"), mode, encoding_overwrite="utf-8" + ) + + src_node = lib2to3_parse( + normalized_contents.lstrip(), target_versions=mode.target_versions + ) + + dst_blocks: list[LinesBlock] = [] + if mode.target_versions: + versions = mode.target_versions + else: + future_imports = get_future_imports(src_node) + versions = detect_target_versions(src_node, future_imports=future_imports) + + line_generation_features = { + feature + for feature in { + Feature.PARENTHESIZED_CONTEXT_MANAGERS, + Feature.UNPARENTHESIZED_EXCEPT_TYPES, + Feature.T_STRINGS, + } + if supports_feature(versions, feature) + } + normalize_fmt_off(src_node, mode, lines) + if lines: + # This should be called after normalize_fmt_off. + convert_unchanged_lines(src_node, lines) + + line_generator = LineGenerator(mode=mode, features=line_generation_features) + elt = EmptyLineTracker(mode=mode) + split_line_features = { + feature + for feature in { + Feature.TRAILING_COMMA_IN_CALL, + Feature.TRAILING_COMMA_IN_DEF, + } + if supports_feature(versions, feature) + } + block: LinesBlock | None = None + for current_line in line_generator.visit(src_node): + block = elt.maybe_empty_lines(current_line) + dst_blocks.append(block) + for line in transform_line( + current_line, mode=mode, features=split_line_features + ): + block.content_lines.append(str(line)) + if dst_blocks: + dst_blocks[-1].after = 0 + dst_contents = [] + for block in dst_blocks: + dst_contents.extend(block.all_lines()) + if not dst_contents: + if "\n" in normalized_contents: + return newline_type + return "".join(dst_contents).replace("\n", newline_type) + + +def decode_bytes( + src: bytes, mode: Mode, *, encoding_overwrite: str | None = None +) -> tuple[FileContent, Encoding, NewLine]: + """Return a tuple of (decoded_contents, encoding, newline). + + `newline` is either CRLF, LF, or CR, but `decoded_contents` is decoded with + universal newlines (i.e. only contains LF). + + Use the keyword only encoding_overwrite argument if the bytes are encoded + differently to their possible encoding magic comment. + """ + srcbuf = io.BytesIO(src) + + # Still use detect encoding even if overwrite set because otherwise lines + # might be different + encoding, lines = tokenize.detect_encoding(srcbuf.readline) + if encoding_overwrite is not None: + encoding = encoding_overwrite + + if not lines: + return "", encoding, "\n" + + if lines[0][-2:] == b"\r\n": + if b"\r" in lines[0][:-2]: + newline = "\r" + else: + newline = "\r\n" + elif lines[0][-1:] == b"\n": + if b"\r" in lines[0][:-1]: + newline = "\r" + else: + newline = "\n" + else: + if b"\r" in lines[0]: + newline = "\r" + else: + newline = "\n" + + srcbuf.seek(0) + with io.TextIOWrapper(srcbuf, encoding) as tiow: + return tiow.read(), encoding, newline + + +def get_features_used( + node: Node, *, future_imports: set[str] | None = None +) -> set[Feature]: + """Return a set of (relatively) new Python features used in this file. + + Currently looking for: + - f-strings; + - self-documenting expressions in f-strings (f"{x=}"); + - underscores in numeric literals; + - trailing commas after * or ** in function signatures and calls; + - positional only arguments in function signatures and lambdas; + - assignment expression; + - relaxed decorator syntax; + - usage of __future__ flags (annotations); + - print / exec statements; + - parenthesized context managers; + - match statements; + - except* clause; + - variadic generics; + - lazy imports; + - starred or double-starred comprehensions. + """ + features: set[Feature] = set() + if future_imports: + features |= { + FUTURE_FLAG_TO_FEATURE[future_import] + for future_import in future_imports + if future_import in FUTURE_FLAG_TO_FEATURE + } + + for n in node.pre_order(): + if n.type == token.FSTRING_START: + features.add(Feature.F_STRINGS) + elif n.type == token.TSTRING_START: + features.add(Feature.T_STRINGS) + elif ( + n.type == token.RBRACE + and n.parent is not None + and any(child.type == token.EQUAL for child in n.parent.children) + ): + features.add(Feature.DEBUG_F_STRINGS) + + elif is_number_token(n): + if "_" in n.value: + features.add(Feature.NUMERIC_UNDERSCORES) + + elif n.type == token.SLASH: + if n.parent and n.parent.type in { + syms.typedargslist, + syms.arglist, + syms.varargslist, + }: + features.add(Feature.POS_ONLY_ARGUMENTS) + + elif n.type == token.COLONEQUAL: + features.add(Feature.ASSIGNMENT_EXPRESSIONS) + + elif n.type == token.LAZY: + features.add(Feature.LAZY_IMPORTS) + + elif n.type == syms.decorator: + if len(n.children) > 1 and not is_simple_decorator_expression( + n.children[1] + ): + features.add(Feature.RELAXED_DECORATORS) + + elif is_unpacking_comprehension(n): + features.add(Feature.UNPACKING_IN_COMPREHENSIONS) + + elif ( + n.type in {syms.typedargslist, syms.arglist} + and n.children + and n.children[-1].type == token.COMMA + ): + if n.type == syms.typedargslist: + feature = Feature.TRAILING_COMMA_IN_DEF + else: + feature = Feature.TRAILING_COMMA_IN_CALL + + for ch in n.children: + if ch.type in STARS: + features.add(feature) + + if ch.type == syms.argument: + for argch in ch.children: + if argch.type in STARS: + features.add(feature) + + elif ( + n.type in {syms.return_stmt, syms.yield_expr} + and len(n.children) >= 2 + and n.children[1].type == syms.testlist_star_expr + and any(child.type == syms.star_expr for child in n.children[1].children) + ): + features.add(Feature.UNPACKING_ON_FLOW) + + elif ( + n.type == syms.annassign + and len(n.children) >= 4 + and n.children[3].type == syms.testlist_star_expr + ): + features.add(Feature.ANN_ASSIGN_EXTENDED_RHS) + + elif ( + n.type == syms.with_stmt + and len(n.children) > 2 + and n.children[1].type == syms.atom + ): + atom_children = n.children[1].children + if ( + len(atom_children) == 3 + and atom_children[0].type == token.LPAR + and _contains_asexpr(atom_children[1]) + and atom_children[2].type == token.RPAR + ): + features.add(Feature.PARENTHESIZED_CONTEXT_MANAGERS) + + elif n.type == syms.match_stmt: + features.add(Feature.PATTERN_MATCHING) + + elif n.type in {syms.subscriptlist, syms.trailer} and any( + child.type == syms.star_expr for child in n.children + ): + features.add(Feature.VARIADIC_GENERICS) + + elif ( + n.type == syms.tname_star + and len(n.children) == 3 + and n.children[2].type == syms.star_expr + ): + features.add(Feature.VARIADIC_GENERICS) + + elif n.type in (syms.type_stmt, syms.typeparams): + features.add(Feature.TYPE_PARAMS) + + elif ( + n.type in (syms.typevartuple, syms.paramspec, syms.typevar) + and n.children[-2].type == token.EQUAL + ): + features.add(Feature.TYPE_PARAM_DEFAULTS) + + elif ( + n.type == syms.except_clause + and len(n.children) >= 2 + and ( + n.children[1].type == token.STAR or n.children[1].type == syms.testlist + ) + ): + is_star_except = n.children[1].type == token.STAR + + if is_star_except: + features.add(Feature.EXCEPT_STAR) + + # Presence of except* pushes as clause 1 index back + has_as_clause = ( + len(n.children) >= is_star_except + 3 + and n.children[is_star_except + 2].type == token.NAME + and n.children[is_star_except + 2].value == "as" # type: ignore + ) + + # If there's no 'as' clause and the except expression is a testlist. + if not has_as_clause and ( + (is_star_except and n.children[2].type == syms.testlist) + or (not is_star_except and n.children[1].type == syms.testlist) + ): + features.add(Feature.UNPARENTHESIZED_EXCEPT_TYPES) + + return features + + +def is_unpacking_comprehension(node: LN) -> bool: + if node.type not in {syms.listmaker, syms.testlist_gexp, syms.dictsetmaker}: + return False + + if not any( + child.type in {syms.comp_for, syms.old_comp_for} for child in node.children + ): + return False + + first_child = node.children[0] + return first_child.type == syms.star_expr or first_child.type == token.DOUBLESTAR + + +def _contains_asexpr(node: Node | Leaf) -> bool: + """Return True if `node` contains an as-pattern.""" + if node.type == syms.asexpr_test: + return True + elif node.type == syms.atom: + if ( + len(node.children) == 3 + and node.children[0].type == token.LPAR + and node.children[2].type == token.RPAR + ): + return _contains_asexpr(node.children[1]) + elif node.type == syms.testlist_gexp: + return any(_contains_asexpr(child) for child in node.children) + return False + + +def detect_target_versions( + node: Node, *, future_imports: set[str] | None = None +) -> set[TargetVersion]: + """Detect the version to target based on the nodes used.""" + features = get_features_used(node, future_imports=future_imports) + return { + version for version in TargetVersion if features <= VERSION_TO_FEATURES[version] + } + + +def get_future_imports(node: Node) -> set[str]: + """Return a set of __future__ imports in the file.""" + imports: set[str] = set() + + def get_imports_from_children(children: list[LN]) -> Generator[str, None, None]: + for child in children: + if isinstance(child, Leaf): + if child.type == token.NAME: + yield child.value + + elif child.type == syms.import_as_name: + orig_name = child.children[0] + assert isinstance(orig_name, Leaf), "Invalid syntax parsing imports" + assert orig_name.type == token.NAME, "Invalid syntax parsing imports" + yield orig_name.value + + elif child.type == syms.import_as_names: + yield from get_imports_from_children(child.children) + + else: + raise AssertionError("Invalid syntax parsing imports") + + for child in node.children: + if child.type != syms.simple_stmt: + break + + first_child = child.children[0] + if isinstance(first_child, Leaf): + # Continue looking if we see a docstring; otherwise stop. + if ( + len(child.children) == 2 + and first_child.type == token.STRING + and child.children[1].type == token.NEWLINE + ): + continue + + break + + elif first_child.type == syms.import_from: + if first_child.children[0].type == token.LAZY: + break + + module_name = first_child.children[1] + if not isinstance(module_name, Leaf) or module_name.value != "__future__": + break + + imports |= set(get_imports_from_children(first_child.children[3:])) + else: + break + + return imports + + +def _black_info() -> str: + return ( + f"Black {__version__} on " + f"Python ({platform.python_implementation()}) {platform.python_version()}" + ) + + +def assert_equivalent(src: str, dst: str) -> None: + """Raise AssertionError if `src` and `dst` aren't equivalent.""" + try: + src_ast = parse_ast(src) + except Exception as exc: + raise SourceASTParseError( + "cannot use --safe with this file; failed to parse source file AST: " + f"{exc}\n" + "This could be caused by running Black with an older Python version " + "that does not support new syntax used in your source file." + ) from exc + + try: + dst_ast = parse_ast(dst) + except Exception as exc: + log = dump_to_file("".join(traceback.format_tb(exc.__traceback__)), dst) + raise ASTSafetyError( + f"INTERNAL ERROR: {_black_info()} produced invalid code: {exc}. " + "Please report a bug on https://github.com/psf/black/issues. " + f"This invalid output might be helpful: {log}" + ) from None + + src_ast_str = "\n".join(stringify_ast(src_ast)) + dst_ast_str = "\n".join(stringify_ast(dst_ast)) + if src_ast_str != dst_ast_str: + log = dump_to_file(diff(src_ast_str, dst_ast_str, "src", "dst")) + raise ASTSafetyError( + f"INTERNAL ERROR: {_black_info()} produced code that is not equivalent to" + " the source. Please report a bug on https://github.com/psf/black/issues." + f" This diff might be helpful: {log}" + ) from None + + +def assert_stable( + src: str, dst: str, mode: Mode, *, lines: Collection[tuple[int, int]] = () +) -> None: + """Raise AssertionError if `dst` reformats differently the second time.""" + if lines: + # Formatting specified lines requires `adjusted_lines` to map original lines + # to the formatted lines before re-formatting the previously formatted result. + # Due to less-ideal diff algorithm, some edge cases produce incorrect new line + # ranges. Hence for now, we skip the stable check. + # See https://github.com/psf/black/issues/4033 for context. + return + # We shouldn't call format_str() here, because that formats the string + # twice and may hide a bug where we bounce back and forth between two + # versions. + newdst = _format_str_once(dst, mode=mode, lines=lines) + if dst != newdst: + log = dump_to_file( + str(mode), + diff(src, dst, "source", "first pass"), + diff(dst, newdst, "first pass", "second pass"), + ) + raise AssertionError( + f"INTERNAL ERROR: {_black_info()} produced different code on the second" + " pass of the formatter. Please report a bug on" + f" https://github.com/psf/black/issues. This diff might be helpful: {log}" + ) from None + + +def patched_main() -> None: + # PyInstaller patches multiprocessing to need freeze_support() even in non-Windows + # environments so just assume we always need to call it if frozen. + if getattr(sys, "frozen", False): + from multiprocessing import freeze_support + + freeze_support() + + main() + + +if __name__ == "__main__": + patched_main() diff --git a/src/black/__main__.py b/src/black/__main__.py new file mode 100644 index 0000000..19b810b --- /dev/null +++ b/src/black/__main__.py @@ -0,0 +1,3 @@ +from black import patched_main + +patched_main() diff --git a/src/black/_width_table.py b/src/black/_width_table.py new file mode 100644 index 0000000..5175357 --- /dev/null +++ b/src/black/_width_table.py @@ -0,0 +1,132 @@ +# Generated by make_width_table.py +# wcwidth 0.2.14 +# Unicode 17.0.0 +from typing import Final + +WIDTH_TABLE: Final[list[tuple[int, int, int]]] = [ + (4352, 4447, 2), + (8986, 8987, 2), + (9001, 9002, 2), + (9193, 9196, 2), + (9200, 9200, 2), + (9203, 9203, 2), + (9725, 9726, 2), + (9748, 9749, 2), + (9776, 9783, 2), + (9800, 9811, 2), + (9855, 9855, 2), + (9866, 9871, 2), + (9875, 9875, 2), + (9889, 9889, 2), + (9898, 9899, 2), + (9917, 9918, 2), + (9924, 9925, 2), + (9934, 9934, 2), + (9940, 9940, 2), + (9962, 9962, 2), + (9970, 9971, 2), + (9973, 9973, 2), + (9978, 9978, 2), + (9981, 9981, 2), + (9989, 9989, 2), + (9994, 9995, 2), + (10024, 10024, 2), + (10060, 10060, 2), + (10062, 10062, 2), + (10067, 10069, 2), + (10071, 10071, 2), + (10133, 10135, 2), + (10160, 10160, 2), + (10175, 10175, 2), + (11035, 11036, 2), + (11088, 11088, 2), + (11093, 11093, 2), + (11904, 11929, 2), + (11931, 12019, 2), + (12032, 12245, 2), + (12272, 12329, 2), + (12336, 12350, 2), + (12353, 12438, 2), + (12443, 12543, 2), + (12549, 12591, 2), + (12593, 12686, 2), + (12688, 12773, 2), + (12783, 12830, 2), + (12832, 12871, 2), + (12880, 42124, 2), + (42128, 42182, 2), + (43360, 43388, 2), + (44032, 55203, 2), + (63744, 64255, 2), + (65040, 65049, 2), + (65072, 65106, 2), + (65108, 65126, 2), + (65128, 65131, 2), + (65281, 65376, 2), + (65504, 65510, 2), + (94176, 94179, 2), + (94194, 94198, 2), + (94208, 101589, 2), + (101631, 101662, 2), + (101760, 101874, 2), + (110576, 110579, 2), + (110581, 110587, 2), + (110589, 110590, 2), + (110592, 110882, 2), + (110898, 110898, 2), + (110928, 110930, 2), + (110933, 110933, 2), + (110948, 110951, 2), + (110960, 111355, 2), + (119552, 119638, 2), + (119648, 119670, 2), + (126980, 126980, 2), + (127183, 127183, 2), + (127374, 127374, 2), + (127377, 127386, 2), + (127488, 127490, 2), + (127504, 127547, 2), + (127552, 127560, 2), + (127568, 127569, 2), + (127584, 127589, 2), + (127744, 127776, 2), + (127789, 127797, 2), + (127799, 127868, 2), + (127870, 127891, 2), + (127904, 127946, 2), + (127951, 127955, 2), + (127968, 127984, 2), + (127988, 127988, 2), + (127992, 127994, 2), + (128000, 128062, 2), + (128064, 128064, 2), + (128066, 128252, 2), + (128255, 128317, 2), + (128331, 128334, 2), + (128336, 128359, 2), + (128378, 128378, 2), + (128405, 128406, 2), + (128420, 128420, 2), + (128507, 128591, 2), + (128640, 128709, 2), + (128716, 128716, 2), + (128720, 128722, 2), + (128725, 128728, 2), + (128732, 128735, 2), + (128747, 128748, 2), + (128756, 128764, 2), + (128992, 129003, 2), + (129008, 129008, 2), + (129292, 129338, 2), + (129340, 129349, 2), + (129351, 129535, 2), + (129648, 129660, 2), + (129664, 129674, 2), + (129678, 129734, 2), + (129736, 129736, 2), + (129741, 129756, 2), + (129759, 129770, 2), + (129775, 129784, 2), + (131072, 196605, 2), + (196608, 262141, 2), +] diff --git a/src/black/brackets.py b/src/black/brackets.py new file mode 100644 index 0000000..6093eb7 --- /dev/null +++ b/src/black/brackets.py @@ -0,0 +1,420 @@ +"""Builds on top of nodes.py to track brackets.""" + +from collections.abc import Iterable, Iterator, Sequence +from dataclasses import dataclass, field +from typing import Final, Union + +from black.nodes import ( + BRACKET, + CLOSING_BRACKETS, + COMPARATORS, + LOGIC_OPERATORS, + MATH_OPERATORS, + OPENING_BRACKETS, + UNPACKING_PARENTS, + VARARGS_PARENTS, + is_vararg, + syms, +) +from blib2to3.pgen2 import token +from blib2to3.pytree import Leaf, Node + +# types +LN = Union[Leaf, Node] +Depth = int +LeafID = int +NodeType = int +Priority = int + + +COMPREHENSION_PRIORITY: Final = 20 +COMMA_PRIORITY: Final = 18 +TERNARY_PRIORITY: Final = 16 +LOGIC_PRIORITY: Final = 14 +STRING_PRIORITY: Final = 12 +COMPARATOR_PRIORITY: Final = 10 +MATH_PRIORITIES: Final = { + token.VBAR: 9, + token.CIRCUMFLEX: 8, + token.AMPER: 7, + token.LEFTSHIFT: 6, + token.RIGHTSHIFT: 6, + token.PLUS: 5, + token.MINUS: 5, + token.STAR: 4, + token.SLASH: 4, + token.DOUBLESLASH: 4, + token.PERCENT: 4, + token.AT: 4, + token.TILDE: 3, + token.DOUBLESTAR: 2, +} +DOT_PRIORITY: Final = 1 + + +class BracketMatchError(Exception): + """Raised when an opening bracket is unable to be matched to a closing bracket.""" + + +@dataclass +class BracketTracker: + """Keeps track of brackets on a line.""" + + depth: int = 0 + bracket_match: dict[tuple[Depth, NodeType], Leaf] = field(default_factory=dict) + delimiters: dict[LeafID, Priority] = field(default_factory=dict) + previous: Leaf | None = None + _for_loop_depths: list[int] = field(default_factory=list) + _lambda_argument_depths: list[int] = field(default_factory=list) + invisible: list[Leaf] = field(default_factory=list) + + def mark(self, leaf: Leaf) -> None: + """Mark `leaf` with bracket-related metadata. Keep track of delimiters. + + All leaves receive an int `bracket_depth` field that stores how deep + within brackets a given leaf is. 0 means there are no enclosing brackets + that started on this line. + + If a leaf is itself a closing bracket and there is a matching opening + bracket earlier, it receives an `opening_bracket` field with which it forms a + pair. This is a one-directional link to avoid reference cycles. Closing + bracket without opening happens on lines continued from previous + breaks, e.g. `) -> "ReturnType":` as part of a funcdef where we place + the return type annotation on its own line of the previous closing RPAR. + + If a leaf is a delimiter (a token on which Black can split the line if + needed) and it's on depth 0, its `id()` is stored in the tracker's + `delimiters` field. + """ + if leaf.type == token.COMMENT: + return + + if ( + self.depth == 0 + and leaf.type in CLOSING_BRACKETS + and (self.depth, leaf.type) not in self.bracket_match + ): + return + + self.maybe_decrement_after_for_loop_variable(leaf) + self.maybe_decrement_after_lambda_arguments(leaf) + if leaf.type in CLOSING_BRACKETS: + self.depth -= 1 + try: + opening_bracket = self.bracket_match.pop((self.depth, leaf.type)) + except KeyError as e: + raise BracketMatchError( + "Unable to match a closing bracket to the following opening" + f" bracket: {leaf}" + ) from e + leaf.opening_bracket = opening_bracket + if not leaf.value: + self.invisible.append(leaf) + leaf.bracket_depth = self.depth + if self.depth == 0: + delim = is_split_before_delimiter(leaf, self.previous) + if delim and self.previous is not None: + self.delimiters[id(self.previous)] = delim + else: + delim = is_split_after_delimiter(leaf) + if delim: + self.delimiters[id(leaf)] = delim + if leaf.type in OPENING_BRACKETS: + self.bracket_match[self.depth, BRACKET[leaf.type]] = leaf + self.depth += 1 + if not leaf.value: + self.invisible.append(leaf) + self.previous = leaf + self.maybe_increment_lambda_arguments(leaf) + self.maybe_increment_for_loop_variable(leaf) + + def any_open_for_or_lambda(self) -> bool: + """Return True if there is an open for or lambda expression on the line. + + See maybe_increment_for_loop_variable and maybe_increment_lambda_arguments + for details.""" + return bool(self._for_loop_depths or self._lambda_argument_depths) + + def any_open_brackets(self) -> bool: + """Return True if there is an yet unmatched open bracket on the line.""" + return bool(self.bracket_match) + + def max_delimiter_priority(self, exclude: Iterable[LeafID] = ()) -> Priority: + """Return the highest priority of a delimiter found on the line. + + Values are consistent with what `is_split_*_delimiter()` return. + Raises ValueError on no delimiters. + """ + return max(v for k, v in self.delimiters.items() if k not in exclude) + + def delimiter_count_with_priority(self, priority: Priority = 0) -> int: + """Return the number of delimiters with the given `priority`. + + If no `priority` is passed, defaults to max priority on the line. + """ + if not self.delimiters: + return 0 + + priority = priority or self.max_delimiter_priority() + return sum(1 for p in self.delimiters.values() if p == priority) + + def maybe_increment_for_loop_variable(self, leaf: Leaf) -> bool: + """In a for loop, or comprehension, the variables are often unpacks. + + To avoid splitting on the comma in this situation, increase the depth of + tokens between `for` and `in`. + """ + if leaf.type == token.NAME and leaf.value == "for": + self.depth += 1 + self._for_loop_depths.append(self.depth) + return True + + return False + + def maybe_decrement_after_for_loop_variable(self, leaf: Leaf) -> bool: + """See `maybe_increment_for_loop_variable` above for explanation.""" + if ( + self._for_loop_depths + and self._for_loop_depths[-1] == self.depth + and leaf.type == token.NAME + and leaf.value == "in" + ): + self.depth -= 1 + self._for_loop_depths.pop() + return True + + return False + + def maybe_increment_lambda_arguments(self, leaf: Leaf) -> bool: + """In a lambda expression, there might be more than one argument. + + To avoid splitting on the comma in this situation, increase the depth of + tokens between `lambda` and `:`. + """ + if leaf.type == token.NAME and leaf.value == "lambda": + self.depth += 1 + self._lambda_argument_depths.append(self.depth) + return True + + return False + + def maybe_decrement_after_lambda_arguments(self, leaf: Leaf) -> bool: + """See `maybe_increment_lambda_arguments` above for explanation.""" + if ( + self._lambda_argument_depths + and self._lambda_argument_depths[-1] == self.depth + and leaf.type == token.COLON + ): + self.depth -= 1 + self._lambda_argument_depths.pop() + return True + + return False + + def get_open_lsqb(self) -> Leaf | None: + """Return the most recent opening square bracket (if any).""" + return self.bracket_match.get((self.depth - 1, token.RSQB)) + + +def is_split_after_delimiter(leaf: Leaf) -> Priority: + """Return the priority of the `leaf` delimiter, given a line break after it. + + The delimiter priorities returned here are from those delimiters that would + cause a line break after themselves. + + Higher numbers are higher priority. + """ + if leaf.type == token.COMMA: + # For-target commas are tuple-packing, not list delimiters; splitting + # on them produces invalid Python if `for` lands on another line (#4296). + parent = leaf.parent + if parent is not None and parent.type == syms.exprlist: + grandparent = parent.parent + if grandparent is not None and grandparent.type in { + syms.comp_for, + syms.old_comp_for, + syms.for_stmt, + }: + return 0 + return COMMA_PRIORITY + + return 0 + + +def is_split_before_delimiter(leaf: Leaf, previous: Leaf | None = None) -> Priority: + """Return the priority of the `leaf` delimiter, given a line break before it. + + The delimiter priorities returned here are from those delimiters that would + cause a line break before themselves. + + Higher numbers are higher priority. + """ + if is_vararg(leaf, within=VARARGS_PARENTS | UNPACKING_PARENTS): + # * and ** might also be MATH_OPERATORS but in this case they are not. + # Don't treat them as a delimiter. + return 0 + + if ( + leaf.type == token.DOT + and leaf.parent + and leaf.parent.type not in {syms.import_from, syms.dotted_name} + and (previous is None or previous.type in CLOSING_BRACKETS) + ): + return DOT_PRIORITY + + if ( + leaf.type in MATH_OPERATORS + and leaf.parent + and leaf.parent.type not in {syms.factor, syms.star_expr} + ): + return MATH_PRIORITIES[leaf.type] + + if leaf.type in COMPARATORS: + return COMPARATOR_PRIORITY + + if ( + leaf.type == token.STRING + and previous is not None + and previous.type == token.STRING + ): + return STRING_PRIORITY + + if leaf.type not in {token.NAME, token.ASYNC}: + return 0 + + if ( + leaf.value == "for" + and leaf.parent + and leaf.parent.type in {syms.comp_for, syms.old_comp_for} + or leaf.type == token.ASYNC + ): + if ( + not isinstance(leaf.prev_sibling, Leaf) + or leaf.prev_sibling.value != "async" + ): + return COMPREHENSION_PRIORITY + + if ( + leaf.value == "if" + and leaf.parent + and leaf.parent.type in {syms.comp_if, syms.old_comp_if} + ): + return COMPREHENSION_PRIORITY + + if leaf.value in {"if", "else"} and leaf.parent and leaf.parent.type == syms.test: + return TERNARY_PRIORITY + + if leaf.value == "is": + return COMPARATOR_PRIORITY + + if ( + leaf.value == "in" + and leaf.parent + and leaf.parent.type in {syms.comp_op, syms.comparison} + and not ( + previous is not None + and previous.type == token.NAME + and previous.value == "not" + ) + ): + return COMPARATOR_PRIORITY + + if ( + leaf.value == "not" + and leaf.parent + and leaf.parent.type == syms.comp_op + and not ( + previous is not None + and previous.type == token.NAME + and previous.value == "is" + ) + ): + return COMPARATOR_PRIORITY + + if leaf.value in LOGIC_OPERATORS and leaf.parent: + return LOGIC_PRIORITY + + return 0 + + +def max_delimiter_priority_in_atom(node: LN) -> Priority: + """Return maximum delimiter priority inside `node`. + + This is specific to atoms with contents contained in a pair of parentheses. + If `node` isn't an atom or there are no enclosing parentheses, returns 0. + """ + if node.type != syms.atom: + return 0 + + first = node.children[0] + last = node.children[-1] + if not (first.type == token.LPAR and last.type == token.RPAR): + return 0 + + bt = BracketTracker() + for leaf in _top_level_leaves(node.children[1:-1]): + bt.mark(leaf) + try: + return bt.max_delimiter_priority() + + except ValueError: + return 0 + + +def _top_level_leaves(children: Iterable[LN]) -> Iterator[Leaf]: + """Yield the leaves that can be top-level (depth 0) delimiters of an atom. + + Anything inside a nested bracket pair is at depth >= 1 and therefore cannot + be a top-level delimiter, so only the pair's brackets are kept (to balance + the depth tracker) and its interior is skipped. This keeps the scan + proportional to the atom's own length instead of re-walking every descendant + on every call, which matters for deeply nested expressions like + ``((((...))))``. + """ + for child in children: + if isinstance(child, Leaf): + yield child + continue + if not child.children: + continue + first = child.children[0] + last = child.children[-1] + if ( + isinstance(first, Leaf) + and isinstance(last, Leaf) + and first.type in OPENING_BRACKETS + and last.type in CLOSING_BRACKETS + ): + yield first + yield last + else: + yield from _top_level_leaves(child.children) + + +def get_leaves_inside_matching_brackets(leaves: Sequence[Leaf]) -> set[LeafID]: + """Return leaves that are inside matching brackets. + + The input `leaves` can have non-matching brackets at the head or tail parts. + Matching brackets are included. + """ + try: + # Start with the first opening bracket and ignore closing brackets before. + start_index = next( + i for i, l in enumerate(leaves) if l.type in OPENING_BRACKETS + ) + except StopIteration: + return set() + bracket_stack = [] + ids = set() + for i in range(start_index, len(leaves)): + leaf = leaves[i] + if leaf.type in OPENING_BRACKETS: + bracket_stack.append((BRACKET[leaf.type], i)) + if leaf.type in CLOSING_BRACKETS: + if bracket_stack and leaf.type == bracket_stack[-1][0]: + _, start = bracket_stack.pop() + for j in range(start, i + 1): + ids.add(id(leaves[j])) + else: + break + return ids diff --git a/src/black/cache.py b/src/black/cache.py new file mode 100644 index 0000000..5882fd6 --- /dev/null +++ b/src/black/cache.py @@ -0,0 +1,150 @@ +"""Caching of formatted files with feature-based invalidation.""" + +import hashlib +import os +import pickle +import sys +import tempfile +from collections.abc import Iterable +from dataclasses import dataclass, field +from pathlib import Path +from typing import NamedTuple + +from platformdirs import user_cache_dir + +from _black_version import version as __version__ +from black.mode import Mode +from black.output import err + +if sys.version_info >= (3, 11): + from typing import Self +else: + from typing_extensions import Self + + +class FileData(NamedTuple): + st_mtime: float + st_size: int + hash: str + + +def get_cache_dir() -> Path: + """Get the cache directory used by black. + + Users can customize this directory on all systems using `BLACK_CACHE_DIR` + environment variable. By default, the cache directory is the user cache directory + under the black application. + + This result is immediately set to a constant `black.cache.CACHE_DIR` as to avoid + repeated calls. + """ + # NOTE: Function mostly exists as a clean way to test getting the cache directory. + default_cache_dir = user_cache_dir("black") + cache_dir = Path(os.environ.get("BLACK_CACHE_DIR", default_cache_dir)) + cache_dir = cache_dir / __version__ + return cache_dir + + +CACHE_DIR = get_cache_dir() + + +def get_cache_file(mode: Mode) -> Path: + return CACHE_DIR / f"cache.{mode.get_cache_key()}.pickle" + + +@dataclass +class Cache: + mode: Mode + cache_file: Path + file_data: dict[str, FileData] = field(default_factory=dict) + + @classmethod + def read(cls, mode: Mode) -> Self: + """Read the cache if it exists and is well-formed. + + If it is not well-formed, the call to write later should + resolve the issue. + """ + cache_file = get_cache_file(mode) + try: + exists = cache_file.exists() + except OSError as e: + # Likely file too long; see #4172 and #4174 + err(f"Unable to read cache file {cache_file} due to {e}") + return cls(mode, cache_file) + if not exists: + return cls(mode, cache_file) + + with cache_file.open("rb") as fobj: + try: + data: dict[str, tuple[float, int, str]] = pickle.load(fobj) + file_data = {k: FileData(*v) for k, v in data.items()} + except (pickle.UnpicklingError, EOFError, ValueError, IndexError): + return cls(mode, cache_file) + + return cls(mode, cache_file, file_data) + + @staticmethod + def hash_digest(path: Path) -> str: + """Return hash digest for path.""" + + data = path.read_bytes() + return hashlib.sha256(data).hexdigest() + + @staticmethod + def get_file_data(path: Path) -> FileData: + """Return file data for path.""" + + stat = path.stat() + hash = Cache.hash_digest(path) + return FileData(stat.st_mtime, stat.st_size, hash) + + def is_changed(self, source: Path) -> bool: + """Check if source has changed compared to cached version.""" + res_src = source.resolve() + old = self.file_data.get(str(res_src)) + if old is None: + return True + + st = res_src.stat() + if st.st_size != old.st_size: + return True + if st.st_mtime != old.st_mtime: + new_hash = Cache.hash_digest(res_src) + if new_hash != old.hash: + return True + return False + + def filtered_cached(self, sources: Iterable[Path]) -> tuple[set[Path], set[Path]]: + """Split an iterable of paths in `sources` into two sets. + + The first contains paths of files that modified on disk or are not in the + cache. The other contains paths to non-modified files. + """ + changed: set[Path] = set() + done: set[Path] = set() + for src in sources: + if self.is_changed(src): + changed.add(src) + else: + done.add(src) + return changed, done + + def write(self, sources: Iterable[Path]) -> None: + """Update the cache file data and write a new cache file.""" + self.file_data.update( + **{str(src.resolve()): Cache.get_file_data(src) for src in sources} + ) + try: + CACHE_DIR.mkdir(parents=True, exist_ok=True) + with tempfile.NamedTemporaryFile( + dir=str(self.cache_file.parent), delete=False + ) as f: + # We store raw tuples in the cache because it's faster. + data: dict[str, tuple[float, int, str]] = { + k: (*v,) for k, v in self.file_data.items() + } + pickle.dump(data, f, protocol=4) + os.replace(f.name, self.cache_file) + except OSError: + pass diff --git a/src/black/comments.py b/src/black/comments.py new file mode 100644 index 0000000..d118e59 --- /dev/null +++ b/src/black/comments.py @@ -0,0 +1,945 @@ +import re +from collections.abc import Collection, Iterator +from dataclasses import dataclass +from functools import lru_cache +from typing import Final, Union + +from black.mode import Mode +from black.nodes import ( + CLOSING_BRACKETS, + OPENING_BRACKETS, + STANDALONE_COMMENT, + STATEMENT, + WHITESPACE, + container_of, + first_leaf_of, + is_type_comment_string, + make_simple_prefix, + preceding_leaf, + syms, +) +from blib2to3.pgen2 import token +from blib2to3.pytree import Leaf, Node + +# types +LN = Union[Leaf, Node] + +FMT_OFF: Final = {"# fmt: off", "# fmt:off", "# yapf: disable"} +FMT_SKIP: Final = {"# fmt: skip", "# fmt:skip"} +FMT_ON: Final = {"# fmt: on", "# fmt:on", "# yapf: enable"} + +# Compound statements we care about for fmt: skip handling +# (excludes except_clause and case_block which aren't standalone compound statements) +_COMPOUND_STATEMENTS: Final = STATEMENT - {syms.except_clause, syms.case_block} + +COMMENT_EXCEPTIONS = " !:#'" +_COMMENT_PREFIX = "# " +_COMMENT_LIST_SEPARATOR = ";" + + +@dataclass +class ProtoComment: + """Describes a piece of syntax that is a comment. + + It's not a :class:`blib2to3.pytree.Leaf` so that: + + * it can be cached (`Leaf` objects should not be reused more than once as + they store their lineno, column, prefix, and parent information); + * `newlines` and `consumed` fields are kept separate from the `value`. This + simplifies handling of special marker comments like ``# fmt: off/on``. + """ + + type: int # token.COMMENT or STANDALONE_COMMENT + value: str # content of the comment + newlines: int # how many newlines before the comment + consumed: int # how many characters of the original leaf's prefix did we consume + form_feed: bool # is there a form feed before the comment + leading_whitespace: str # leading whitespace before the comment, if any + + +def generate_comments(leaf: LN, mode: Mode) -> Iterator[Leaf]: + """Clean the prefix of the `leaf` and generate comments from it, if any. + + Comments in lib2to3 are shoved into the whitespace prefix. This happens + in `pgen2/driver.py:Driver.parse_tokens()`. This was a brilliant implementation + move because it does away with modifying the grammar to include all the + possible places in which comments can be placed. + + The sad consequence for us though is that comments don't "belong" anywhere. + This is why this function generates simple parentless Leaf objects for + comments. We simply don't know what the correct parent should be. + + No matter though, we can live without this. We really only need to + differentiate between inline and standalone comments. The latter don't + share the line with any code. + + Inline comments are emitted as regular token.COMMENT leaves. Standalone + are emitted with a fake STANDALONE_COMMENT token identifier. + """ + total_consumed = 0 + for pc in list_comments( + leaf.prefix, is_endmarker=leaf.type == token.ENDMARKER, mode=mode + ): + total_consumed = pc.consumed + prefix = make_simple_prefix(pc.newlines, pc.form_feed) + yield Leaf(pc.type, pc.value, prefix=prefix) + normalize_trailing_prefix(leaf, total_consumed) + + +@lru_cache(maxsize=4096) +def list_comments(prefix: str, *, is_endmarker: bool, mode: Mode) -> list[ProtoComment]: + """Return a list of :class:`ProtoComment` objects parsed from the given `prefix`.""" + result: list[ProtoComment] = [] + if not prefix or "#" not in prefix: + return result + + consumed = 0 + nlines = 0 + ignored_lines = 0 + form_feed = False + for index, full_line in enumerate(re.split("\r?\n|\r", prefix)): + consumed += len(full_line) + 1 # adding the length of the split '\n' + match = re.match(r"^(\s*)(\S.*|)$", full_line) + assert match + whitespace, line = match.groups() + if not line: + nlines += 1 + if "\f" in full_line: + form_feed = True + if not line.startswith("#"): + # Escaped newlines outside of a comment are not really newlines at + # all. We treat a single-line comment following an escaped newline + # as a simple trailing comment. + if line.endswith("\\"): + ignored_lines += 1 + continue + + if index == ignored_lines and not is_endmarker: + comment_type = token.COMMENT # simple trailing comment + else: + comment_type = STANDALONE_COMMENT + comment = make_comment(line, mode=mode) + result.append( + ProtoComment( + type=comment_type, + value=comment, + newlines=nlines, + consumed=consumed, + form_feed=form_feed, + leading_whitespace=whitespace, + ) + ) + form_feed = False + nlines = 0 + return result + + +def normalize_trailing_prefix(leaf: LN, total_consumed: int) -> None: + """Normalize the prefix that's left over after generating comments. + + Note: don't use backslashes for formatting or you'll lose your voting rights. + """ + remainder = leaf.prefix[total_consumed:] + if "\\" not in remainder: + nl_count = remainder.count("\n") + form_feed = "\f" in remainder and remainder.endswith("\n") + leaf.prefix = make_simple_prefix(nl_count, form_feed) + return + + leaf.prefix = "" + + +def make_comment(content: str, mode: Mode) -> str: + """Return a consistently formatted comment from the given `content` string. + + All comments (except for "##", "#!", "#:", '#'") should have a single + space between the hash sign and the content. + + If `content` didn't start with a hash sign, one is provided. + + Comments containing fmt directives are preserved exactly as-is to respect + user intent (e.g., `#no space # fmt: skip` stays as-is). + """ + content = content.rstrip() + if not content: + return "#" + + # Preserve comments with fmt directives exactly as-is + if content.startswith("#") and contains_fmt_directive(content): + return content + + if content[0] == "#": + content = content[1:] + if ( + content + and content[0] == "\N{NO-BREAK SPACE}" + and not is_type_comment_string("# " + content.lstrip(), mode=mode) + ): + content = " " + content[1:] # Replace NBSP by a simple space + if ( + content + and "\N{NO-BREAK SPACE}" not in content + and is_type_comment_string("#" + content, mode=mode) + ): + type_part, value_part = content.split(":", 1) + content = type_part.strip() + ": " + value_part.strip() + + if content and content[0] not in COMMENT_EXCEPTIONS: + content = " " + content + return "#" + content + + +def normalize_fmt_off( + node: Node, mode: Mode, lines: Collection[tuple[int, int]] +) -> None: + """Convert content between `# fmt: off`/`# fmt: on` into standalone comments.""" + # Walk the leaves once and resume scanning from the last converted position + # instead of restarting from the root for every pair. Converting a pair only + # mutates the tree at or after the converted leaf, so earlier leaves never + # need to be revisited. + leaves = list(node.leaves()) + # Per-parent hint of where the previous conversion removed a child, so the + # left-to-right removals below don't rescan each parent's children list from + # index 0 every time (quadratic when a file has many `# fmt: off` blocks + # sharing one parent). + search_hints: dict[int, int] = {} + i = 0 + while i < len(leaves): + i = convert_one_fmt_off_pair(node, leaves, i, mode, lines, search_hints) + + +def _should_process_fmt_comment( + comment: ProtoComment, leaf: Leaf +) -> tuple[bool, bool, bool]: + """Check if comment should be processed for fmt handling. + + Returns (should_process, is_fmt_off, is_fmt_skip). + """ + is_fmt_off = contains_fmt_directive(comment.value, FMT_OFF) + is_fmt_skip = contains_fmt_directive(comment.value, FMT_SKIP) + + if not is_fmt_off and not is_fmt_skip: + return False, False, False + + # Invalid use when `# fmt: off` is applied before a closing bracket + if is_fmt_off and leaf.type in CLOSING_BRACKETS: + return False, False, False + + return True, is_fmt_off, is_fmt_skip + + +def _is_valid_standalone_fmt_comment( + comment: ProtoComment, leaf: Leaf, is_fmt_off: bool, is_fmt_skip: bool +) -> bool: + """Check if comment is a valid standalone fmt directive. + + We only want standalone comments. If there's no previous leaf or if + the previous leaf is indentation, it's a standalone comment in disguise. + """ + if comment.type == STANDALONE_COMMENT: + return True + + prev = preceding_leaf(leaf) + if not prev: + return True + + # Treat STANDALONE_COMMENT nodes as whitespace for check + if is_fmt_off and prev.type not in WHITESPACE and prev.type != STANDALONE_COMMENT: + return False + if is_fmt_skip and prev.type in WHITESPACE: + return False + + return True + + +def _handle_comment_only_fmt_block( + leaf: Leaf, + comment: ProtoComment, + previous_consumed: int, + mode: Mode, +) -> bool: + """Handle fmt:off/on blocks that contain only comments. + + Returns True if a block was converted, False otherwise. + """ + all_comments = list_comments(leaf.prefix, is_endmarker=False, mode=mode) + + # Find the first fmt:off and its matching fmt:on + fmt_off_idx = None + fmt_on_idx = None + for idx, c in enumerate(all_comments): + if fmt_off_idx is None and contains_fmt_directive(c.value, FMT_OFF): + fmt_off_idx = idx + if ( + fmt_off_idx is not None + and idx > fmt_off_idx + and contains_fmt_directive(c.value, FMT_ON) + ): + fmt_on_idx = idx + break + + # Only proceed if we found both directives + if fmt_on_idx is None or fmt_off_idx is None: + return False + + comment = all_comments[fmt_off_idx] + fmt_on_comment = all_comments[fmt_on_idx] + original_prefix = leaf.prefix + + # Build the hidden value + start_pos = comment.consumed + end_pos = fmt_on_comment.consumed + content_between_and_fmt_on = original_prefix[start_pos:end_pos] + hidden_value = comment.value + "\n" + content_between_and_fmt_on + + if hidden_value.endswith("\n"): + hidden_value = hidden_value[:-1] + + # Build the standalone comment prefix - preserve all content before fmt:off + # including any comments that precede it + if fmt_off_idx == 0: + # No comments before fmt:off, use previous_consumed + pre_fmt_off_consumed = previous_consumed + else: + # Use the consumed position of the last comment before fmt:off + # This preserves all comments and content before the fmt:off directive + pre_fmt_off_consumed = all_comments[fmt_off_idx - 1].consumed + + preceding_prefix = original_prefix[:pre_fmt_off_consumed] + if fmt_off_idx > 0: + preceding_prefix = preceding_prefix.lstrip("\r\n") + + standalone_comment_prefix = preceding_prefix + "\n" * comment.newlines + + fmt_off_prefix = original_prefix.split(comment.value)[0] + if "\n" in fmt_off_prefix: + fmt_off_prefix = fmt_off_prefix.split("\n")[-1] + standalone_comment_prefix += fmt_off_prefix + + # Update leaf prefix + leaf.prefix = original_prefix[fmt_on_comment.consumed :] + + # Insert the STANDALONE_COMMENT + parent = leaf.parent + assert parent is not None, "INTERNAL ERROR: fmt: on/off handling (prefix only)" + + leaf_idx = None + for idx, child in enumerate(parent.children): + if child is leaf: + leaf_idx = idx + break + + assert leaf_idx is not None, "INTERNAL ERROR: fmt: on/off handling (leaf index)" + + parent.insert_child( + leaf_idx, + Leaf( + STANDALONE_COMMENT, + hidden_value, + prefix=standalone_comment_prefix, + fmt_pass_converted_first_leaf=None, + ), + ) + return True + + +def convert_one_fmt_off_pair( + node: Node, + leaves: list[Leaf], + start: int, + mode: Mode, + lines: Collection[tuple[int, int]], + search_hints: dict[int, int] | None = None, +) -> int: + """Convert content of a single `# fmt: off`/`# fmt: on` into a standalone comment. + + Scans `leaves` starting at `start`. Returns the index to resume scanning from: + the index of the leaf that was just converted (so further directives on the same + leaf are reconsidered), or ``len(leaves)`` when no further pair is found. + """ + for idx in range(start, len(leaves)): + leaf = leaves[idx] + # A previous conversion may have detached this leaf from the tree (e.g. it + # was absorbed into a fmt: off block); such leaves are already handled. + if not _is_attached(leaf, node): + continue + + # Skip STANDALONE_COMMENT nodes that were created by fmt:off/on/skip processing + # to avoid reprocessing them in subsequent iterations + if leaf.type == STANDALONE_COMMENT and hasattr( + leaf, "fmt_pass_converted_first_leaf" + ): + continue + + previous_consumed = 0 + for comment in list_comments(leaf.prefix, is_endmarker=False, mode=mode): + should_process, is_fmt_off, is_fmt_skip = _should_process_fmt_comment( + comment, leaf + ) + if not should_process: + previous_consumed = comment.consumed + continue + + if not _is_valid_standalone_fmt_comment( + comment, leaf, is_fmt_off, is_fmt_skip + ): + previous_consumed = comment.consumed + continue + + ignored_nodes = list(generate_ignored_nodes(leaf, comment, mode)) + + # Handle comment-only blocks + if not ignored_nodes and is_fmt_off: + if _handle_comment_only_fmt_block( + leaf, comment, previous_consumed, mode + ): + return idx + continue + + # Need actual nodes to process + if not ignored_nodes: + continue + + # Handle regular fmt blocks + + _handle_regular_fmt_block( + ignored_nodes, + comment, + previous_consumed, + is_fmt_skip, + lines, + leaf, + search_hints, + ) + return idx + + return len(leaves) + + +def _is_attached(leaf: Leaf, root: Node) -> bool: + """Return whether `leaf` is still reachable from `root` through its parents.""" + current: LN | None = leaf + while current is not None: + if current is root: + return True + current = current.parent + return False + + +def _handle_regular_fmt_block( + ignored_nodes: list[LN], + comment: ProtoComment, + previous_consumed: int, + is_fmt_skip: bool, + lines: Collection[tuple[int, int]], + leaf: Leaf, + search_hints: dict[int, int] | None = None, +) -> None: + """Handle fmt blocks with actual AST nodes.""" + first = ignored_nodes[0] # Can be a container node with the `leaf`. + parent = first.parent + prefix = first.prefix + + if contains_fmt_directive(comment.value, FMT_OFF): + first.prefix = prefix[comment.consumed :] + if is_fmt_skip: + first.prefix = "" + standalone_comment_prefix = prefix + else: + standalone_comment_prefix = prefix[:previous_consumed] + "\n" * comment.newlines + + # Ensure STANDALONE_COMMENT nodes have trailing newlines when stringified + # This prevents multiple fmt: skip comments from being concatenated on one line + parts = [] + for node in ignored_nodes: + if isinstance(node, Leaf) and node.type == STANDALONE_COMMENT: + # Add newline after STANDALONE_COMMENT Leaf + node_str = str(node) + if not node_str.endswith("\n"): + node_str += "\n" + parts.append(node_str) + elif isinstance(node, Node): + # For nodes that might contain STANDALONE_COMMENT leaves, + # we need custom stringify + has_standalone = any( + leaf.type == STANDALONE_COMMENT for leaf in node.leaves() + ) + if has_standalone: + # Stringify node with STANDALONE_COMMENT leaves having trailing newlines + def stringify_node(n: LN) -> str: + if isinstance(n, Leaf): + if n.type == STANDALONE_COMMENT: + result = n.prefix + n.value + if not result.endswith("\n"): + result += "\n" + return result + return str(n) + else: + # For nested nodes, recursively process children + return "".join(stringify_node(child) for child in n.children) + + parts.append(stringify_node(node)) + else: + parts.append(str(node)) + else: + parts.append(str(node)) + + hidden_value = "".join(parts) + comment_lineno = leaf.lineno - comment.newlines + leaf_is_ignored = any( + ignored is leaf + or ( + isinstance(ignored, Node) + and any(child is leaf for child in ignored.leaves()) + ) + for ignored in ignored_nodes + ) + + if contains_fmt_directive(comment.value, FMT_OFF): + fmt_off_prefix = "" + if len(lines) > 0 and not any( + line[0] <= comment_lineno <= line[1] for line in lines + ): + # keeping indentation of comment by preserving original whitespaces. + fmt_off_prefix = prefix.split(comment.value)[0] + if "\n" in fmt_off_prefix: + fmt_off_prefix = fmt_off_prefix.split("\n")[-1] + standalone_comment_prefix += fmt_off_prefix + hidden_value = comment.value + "\n" + hidden_value + + if is_fmt_skip and not leaf_is_ignored: + hidden_value += comment.leading_whitespace + comment.value + + if hidden_value.endswith("\n"): + # That happens when one of the `ignored_nodes` ended with a NEWLINE + # leaf (possibly followed by a DEDENT). + hidden_value = hidden_value[:-1] + + first_idx: int | None = None + for ignored in ignored_nodes: + ignored_parent = ignored.parent + hint = ( + search_hints.get(id(ignored_parent), 0) + if search_hints is not None and ignored_parent is not None + else 0 + ) + index = ignored.remove(hint) + if ( + index is not None + and search_hints is not None + and ignored_parent is not None + ): + search_hints[id(ignored_parent)] = index + if first_idx is None: + first_idx = index + + assert parent is not None, "INTERNAL ERROR: fmt: on/off handling (1)" + assert first_idx is not None, "INTERNAL ERROR: fmt: on/off handling (2)" + + parent.insert_child( + first_idx, + Leaf( + STANDALONE_COMMENT, + hidden_value, + prefix=standalone_comment_prefix, + fmt_pass_converted_first_leaf=first_leaf_of(first), + ), + ) + + +def generate_ignored_nodes( + leaf: Leaf, comment: ProtoComment, mode: Mode +) -> Iterator[LN]: + """Starting from the container of `leaf`, generate all leaves until `# fmt: on`. + + If comment is skip, returns leaf only. + Stops at the end of the block. + """ + if contains_fmt_directive(comment.value, FMT_SKIP): + yield from _generate_ignored_nodes_from_fmt_skip(leaf, comment, mode) + return + container: LN | None = container_of(leaf) + while container is not None and container.type != token.ENDMARKER: + if is_fmt_on(container, mode=mode): + return + + # fix for fmt: on in children + if children_contains_fmt_on(container, mode=mode): + for index, child in enumerate(container.children): + if isinstance(child, Leaf) and is_fmt_on(child, mode=mode): + if child.type in CLOSING_BRACKETS: + # This means `# fmt: on` is placed at a different bracket level + # than `# fmt: off`. This is an invalid use, but as a courtesy, + # we include this closing bracket in the ignored nodes. + # The alternative is to fail the formatting. + yield child + return + if ( + child.type == token.INDENT + and index < len(container.children) - 1 + and children_contains_fmt_on( + container.children[index + 1], mode=mode + ) + ): + # This means `# fmt: on` is placed right after an indentation + # level, and we shouldn't swallow the previous INDENT token. + return + if children_contains_fmt_on(child, mode=mode): + return + yield child + else: + if container.type == token.DEDENT and container.next_sibling is None: + # This can happen when there is no matching `# fmt: on` comment at the + # same level as `# fmt: on`. We need to keep this DEDENT. + return + yield container + container = container.next_sibling + + +def _find_compound_statement_context(parent: Node) -> Node | None: + """Return the body node of a compound statement if we should respect fmt: skip. + + This handles one-line compound statements like: + if condition: body # fmt: skip + + When Black expands such statements, they temporarily look like: + if condition: + body # fmt: skip + + In both cases, we want to return the body node (either the simple_stmt directly + or the suite containing it). + """ + if parent.type != syms.simple_stmt: + return None + + if not isinstance(parent.parent, Node): + return None + + # Case 1: Expanded form after Black's initial formatting pass. + # The one-liner has been split across multiple lines: + # if True: + # print("a"); print("b") # fmt: skip + # Structure: compound_stmt -> suite -> simple_stmt + if ( + parent.parent.type == syms.suite + and isinstance(parent.parent.parent, Node) + and parent.parent.parent.type in _COMPOUND_STATEMENTS + ): + return parent.parent + + # Case 2: Original one-line form from the input source. + # The statement is still on a single line: + # if True: print("a"); print("b") # fmt: skip + # Structure: compound_stmt -> simple_stmt + if parent.parent.type in _COMPOUND_STATEMENTS: + return parent + + return None + + +def _should_keep_compound_statement_inline( + body_node: Node, simple_stmt_parent: Node +) -> bool: + """Check if a compound statement should be kept on one line. + + Returns True only for compound statements with semicolon-separated bodies, + like: if True: print("a"); print("b") # fmt: skip + """ + # Narrow down to the single simple_stmt that may carry the semicolons before + # scanning any leaves. A compound statement's suite holds one child per body + # statement, so walking the whole suite here is O(n) and, called once per + # `# fmt: skip` line in the block, makes the pass O(n^2). + if body_node.type == syms.suite: + # After formatting: the suite must hold exactly one simple_stmt and it + # must be the one carrying the directive. Stop at the second simple_stmt. + target: LN | None = None + for child in body_node.children: + if child.type == syms.simple_stmt: + if target is not None: + return False + target = child + if target is None or target is not simple_stmt_parent: + return False + else: + # Original form: body_node IS the simple_stmt + if body_node is not simple_stmt_parent: + return False + target = body_node + + return any(leaf.type == token.SEMI for leaf in target.leaves()) + + +def _get_compound_statement_header( + body_node: Node, simple_stmt_parent: Node +) -> list[LN]: + """Get header nodes for a compound statement that should be preserved inline.""" + if not _should_keep_compound_statement_inline(body_node, simple_stmt_parent): + return [] + + # Get the compound statement (parent of body) + compound_stmt = body_node.parent + if compound_stmt is None or compound_stmt.type not in _COMPOUND_STATEMENTS: + return [] + + # Collect all header leaves before the body + header_leaves: list[LN] = [] + for child in compound_stmt.children: + if child is body_node: + break + if isinstance(child, Leaf): + if child.type not in (token.NEWLINE, token.INDENT): + header_leaves.append(child) + else: + header_leaves.extend(child.leaves()) + return header_leaves + + +def _find_closest_previous_sibling(node: LN) -> LN | None: + """Find the closest previous sibling by walking up the ancestor chain.""" + current: LN | None = node + while current is not None: + prev_sibling = current.prev_sibling + if prev_sibling is not None: + return prev_sibling + current = current.parent + return None + + +def _generate_ignored_nodes_from_fmt_skip( + leaf: Leaf, comment: ProtoComment, mode: Mode +) -> Iterator[LN]: + """Generate all leaves that should be ignored by the `# fmt: skip` from `leaf`.""" + prev_sibling = leaf.prev_sibling + parent = leaf.parent + ignored_nodes: list[LN] = [] + # Need to properly format the leaf prefix to compare it to comment.value, + # which is also formatted + comments = list_comments(leaf.prefix, is_endmarker=False, mode=mode) + if not comments or comment.value != comments[0].value: + return + + if prev_sibling is None and parent is not None: + prev_sibling = parent.prev_sibling + + if prev_sibling is None and comment.type == token.COMMENT: + prev_sibling = _find_closest_previous_sibling(leaf) + + if parent is not None and parent.type == syms.suite and leaf.type == token.NEWLINE: + # The `# fmt: skip` is on the colon line of the if/while/def/class/... + # statements. The ignored nodes should be previous siblings of the + # parent suite node. Do this before the generic "same physical line" + # logic so multiline headers are preserved as a whole. + leaf.prefix = "" + parent_sibling = parent.prev_sibling + while parent_sibling is not None and parent_sibling.type != syms.suite: + ignored_nodes.insert(0, parent_sibling) + parent_sibling = parent_sibling.prev_sibling + # Special case for `async_stmt` where the ASYNC token is on the + # grandparent node. + grandparent = parent.parent + if ( + grandparent is not None + and grandparent.prev_sibling is not None + and grandparent.prev_sibling.type == token.ASYNC + ): + ignored_nodes.insert(0, grandparent.prev_sibling) + yield from iter(ignored_nodes) + elif prev_sibling is not None: + # Generates the nodes to be ignored by `fmt: skip`. + + # Nodes to ignore are the ones on the same line as the + # `# fmt: skip` comment, excluding the `# fmt: skip` + # node itself. + + # Traversal process (starting at the `# fmt: skip` node): + # 1. Move to the `prev_sibling` of the current node. + # 2. If `prev_sibling` has children, go to its rightmost leaf. + # 3. If there's no `prev_sibling`, move up to the parent + # node and repeat. + # 4. Continue until: + # a. You encounter an `INDENT` or `NEWLINE` node (indicates + # start of the line). + # b. You reach the root node. + + # Include all visited LEAVES in the ignored list, except INDENT + # or NEWLINE leaves. + + current_node = prev_sibling + if ( + isinstance(current_node, Leaf) + and current_node.type in OPENING_BRACKETS + and current_node.parent + and current_node.parent.type == syms.atom + ): + current_node = current_node.parent + + ignored_nodes = [current_node] + if current_node.prev_sibling is None and current_node.parent is not None: + current_node = current_node.parent + + # Track seen nodes to detect cycles that can occur after tree modifications + seen_nodes = {id(current_node)} + + while "\n" not in current_node.prefix and current_node.prev_sibling is not None: + leaf_nodes = list(current_node.prev_sibling.leaves()) + next_node = leaf_nodes[-1] if leaf_nodes else current_node + + # Detect infinite loop - if we've seen this node before, stop + # This can happen when STANDALONE_COMMENT nodes are inserted + # during processing + if id(next_node) in seen_nodes: + break + + current_node = next_node + seen_nodes.add(id(current_node)) + + # Stop if we encounter a STANDALONE_COMMENT created by fmt processing + if ( + isinstance(current_node, Leaf) + and current_node.type == STANDALONE_COMMENT + and hasattr(current_node, "fmt_pass_converted_first_leaf") + ): + break + + if ( + current_node.type in CLOSING_BRACKETS + and current_node.parent + and current_node.parent.type == syms.atom + ): + current_node = current_node.parent + + if current_node.type in (token.NEWLINE, token.INDENT): + if not list_comments( + current_node.prefix, is_endmarker=False, mode=mode + ): + current_node.prefix = "" + break + + if current_node.type == token.DEDENT: + break + + # Special case for with expressions + # Without this, we can stuck inside the asexpr_test's children's children + if ( + current_node.parent + and current_node.parent.type == syms.asexpr_test + and current_node.parent.parent + and current_node.parent.parent.type == syms.with_stmt + ): + current_node = current_node.parent + + ignored_nodes.insert(0, current_node) + + if current_node.prev_sibling is None and current_node.parent is not None: + current_node = current_node.parent + + # Special handling for compound statements with semicolon-separated bodies + if isinstance(parent, Node): + body_node = _find_compound_statement_context(parent) + if body_node is not None: + header_nodes = _get_compound_statement_header(body_node, parent) + if header_nodes: + ignored_nodes = header_nodes + ignored_nodes + + # If the nodes captured for the comment's physical line leave a bracket + # open, the `# fmt: skip` sits inside a multi-line bracketed statement + # (e.g. on the `from x import (` line). Skipping only that line would + # reformat the rest of the statement, so preserve the whole enclosing + # statement instead. + bracket_depth = 0 + for node in ignored_nodes: + for ignored_leaf in node.leaves(): + if ignored_leaf.type in OPENING_BRACKETS: + bracket_depth += 1 + elif ignored_leaf.type in CLOSING_BRACKETS: + bracket_depth -= 1 + if bracket_depth > 0: + statement: LN = leaf + while statement.parent is not None and statement.parent.type not in ( + syms.file_input, + syms.suite, + ): + statement = statement.parent + ignored_nodes = [statement] + + leaf_is_ignored = any( + ignored is leaf + or ( + isinstance(ignored, Node) + and any(child is leaf for child in ignored.leaves()) + ) + for ignored in ignored_nodes + ) + if not leaf_is_ignored: + leaf.prefix = leaf.prefix[comment.consumed :] + + yield from ignored_nodes + + +def is_fmt_on(container: LN, mode: Mode) -> bool: + """Determine whether formatting is switched on within a container. + Determined by whether the last `# fmt:` comment is `on` or `off`. + """ + fmt_on = False + for comment in list_comments(container.prefix, is_endmarker=False, mode=mode): + if contains_fmt_directive(comment.value, FMT_ON): + fmt_on = True + elif contains_fmt_directive(comment.value, FMT_OFF): + fmt_on = False + return fmt_on + + +def children_contains_fmt_on(container: LN, mode: Mode) -> bool: + """Determine if children have formatting switched on.""" + for child in container.children: + leaf = first_leaf_of(child) + if leaf is not None and is_fmt_on(leaf, mode=mode): + return True + + return False + + +def contains_pragma_comment(comment_list: list[Leaf]) -> bool: + """ + Returns: + True iff one of the comments in @comment_list is a pragma used by one + of the more common static analysis tools for python (e.g. mypy, flake8, + pylint). + """ + for comment in comment_list: + if comment.value.startswith(("# type:", "# noqa", "# pylint:")): + return True + + return False + + +def contains_fmt_directive( + comment_line: str, directives: set[str] = FMT_OFF | FMT_ON | FMT_SKIP +) -> bool: + """ + Checks if the given comment contains format directives, alone or paired with + other comments. + + Defaults to checking all directives (skip, off, on, yapf), but can be + narrowed to specific ones. + + Matching styles: + # foobar <-- single comment + # foobar # foobar # foobar <-- multiple comments + # foobar; foobar <-- list of comments (; separated) + """ + semantic_comment_blocks = [ + comment_line, + *[ + _COMMENT_PREFIX + comment.strip() + for comment in comment_line.split(_COMMENT_PREFIX)[1:] + ], + *[ + _COMMENT_PREFIX + comment.strip() + for comment in comment_line.strip(_COMMENT_PREFIX).split( + _COMMENT_LIST_SEPARATOR + ) + ], + ] + + return any(comment in directives for comment in semantic_comment_blocks) diff --git a/src/black/concurrency.py b/src/black/concurrency.py new file mode 100644 index 0000000..09ab971 --- /dev/null +++ b/src/black/concurrency.py @@ -0,0 +1,236 @@ +""" +Formatting many files at once via multiprocessing. Contains entrypoint and utilities. + +NOTE: this module is only imported if we need to format several files at once. +""" + +from __future__ import annotations + +import asyncio +import logging +import os +import signal +import sys +import traceback +from collections.abc import Iterable +from concurrent.futures import Executor, ProcessPoolExecutor, ThreadPoolExecutor +from multiprocessing import Manager +from pathlib import Path +from typing import Any + +import click +from mypy_extensions import mypyc_attr + +from black import WriteBack, format_file_in_place +from black.cache import Cache +from black.mode import Mode +from black.output import err +from black.report import Changed, Report + + +def maybe_use_uvloop() -> asyncio.AbstractEventLoop: + """If our environment has uvloop or winloop installed we use it otherwise + a normal asyncio eventloop is called as fallback. + + This is called only from command-line entry points to avoid + interfering with the parent process if Black is used as a library. + """ + try: + if sys.platform != "win32": + import uvloop + + return uvloop.new_event_loop() + else: + import winloop + + return winloop.new_event_loop() + except ImportError: + return asyncio.new_event_loop() + + +def cancel(tasks: Iterable[asyncio.Future[Any]]) -> None: + """asyncio signal handler that cancels all `tasks` and reports to stderr.""" + err("Aborted!") + for task in tasks: + task.cancel() + + +def shutdown(loop: asyncio.AbstractEventLoop) -> None: + """Cancel all pending tasks on `loop`, wait for them, and close the loop.""" + try: + # This part is borrowed from asyncio/runners.py in Python 3.7b2. + to_cancel = [task for task in asyncio.all_tasks(loop) if not task.done()] + if not to_cancel: + return + + for task in to_cancel: + task.cancel() + loop.run_until_complete(asyncio.gather(*to_cancel, return_exceptions=True)) + finally: + # `concurrent.futures.Future` objects cannot be cancelled once they + # are already running. There might be some when the `shutdown()` happened. + # Silence their logger's spew about the event loop being closed. + cf_logger = logging.getLogger("concurrent.futures") + cf_logger.setLevel(logging.CRITICAL) + loop.close() + + +# diff-shades depends on being to monkeypatch this function to operate. I know it's +# not ideal, but this shouldn't cause any issues ... hopefully. ~ichard26 +@mypyc_attr(patchable=True) +def reformat_many( + sources: set[Path], + fast: bool, + write_back: WriteBack, + mode: Mode, + report: Report, + workers: int | None, + no_cache: bool = False, +) -> None: + """Reformat multiple files using a ProcessPoolExecutor.""" + + if workers is None: + workers_value = os.environ.get("BLACK_NUM_WORKERS") + if workers_value is not None: + try: + workers = int(workers_value) + except ValueError: + raise click.BadParameter( + f"{workers_value!r} is not a valid integer", + param_hint="BLACK_NUM_WORKERS", + ) from None + if workers < 1: + raise click.BadParameter( + f"{workers_value!r} is not in the range x>=1", + param_hint="BLACK_NUM_WORKERS", + ) + else: + workers = os.cpu_count() or 1 + if sys.platform == "win32": + # Work around https://bugs.python.org/issue26903 + workers = min(workers, 60) + if getattr(sys, "frozen", False): + # In frozen builds (e.g. PyInstaller), avoid spawning worker processes (i.e. + # avoid using ProcessPoolExecutor) to prevent shutdown errors when workers + # try to import modules after cleanup begins. + # See https://github.com/psf/black/issues/4823 + workers = 1 + + executor: Executor | None = None + if workers > 1: + try: + executor = ProcessPoolExecutor(max_workers=workers) + except (ImportError, NotImplementedError, OSError): + # we arrive here if the underlying system does not support multi-processing + # like in AWS Lambda or Termux, in which case we gracefully fallback to + # a ThreadPoolExecutor with just a single worker (more workers would not do + # us any good due to the Global Interpreter Lock) + pass + + if executor is None: + executor = ThreadPoolExecutor(max_workers=1) + + loop = maybe_use_uvloop() + asyncio.set_event_loop(loop) + try: + loop.run_until_complete( + schedule_formatting( + sources=sources, + fast=fast, + write_back=write_back, + mode=mode, + report=report, + loop=loop, + executor=executor, + no_cache=no_cache, + ) + ) + finally: + try: + shutdown(loop) + finally: + asyncio.set_event_loop(None) + if executor is not None: + executor.shutdown() + + +async def schedule_formatting( + sources: set[Path], + fast: bool, + write_back: WriteBack, + mode: Mode, + report: Report, + loop: asyncio.AbstractEventLoop, + executor: Executor, + no_cache: bool = False, +) -> None: + """Run formatting of `sources` in parallel using the provided `executor`. + + (Use ProcessPoolExecutors for actual parallelism.) + + `write_back`, `fast`, and `mode` options are passed to + :func:`format_file_in_place`. + """ + cache = None if no_cache else Cache.read(mode) + if cache is not None and write_back not in ( + WriteBack.DIFF, + WriteBack.COLOR_DIFF, + ): + sources, cached = cache.filtered_cached(sources) + for src in sorted(cached): + report.done(src, Changed.CACHED) + if not sources: + return + + cancelled = [] + sources_to_cache = [] + lock = None + manager = None + if write_back in (WriteBack.DIFF, WriteBack.COLOR_DIFF): + # For diff output, we need locks to ensure we don't interleave output + # from different processes. + manager = Manager() + lock = manager.Lock() + + try: + tasks = { + asyncio.ensure_future( + loop.run_in_executor( + executor, format_file_in_place, src, fast, mode, write_back, lock + ) + ): src + for src in sorted(sources) + } + pending = tasks.keys() + try: + loop.add_signal_handler(signal.SIGINT, cancel, pending) + loop.add_signal_handler(signal.SIGTERM, cancel, pending) + except NotImplementedError: + # There are no good alternatives for these on Windows. + pass + while pending: + done, _ = await asyncio.wait(pending, return_when=asyncio.FIRST_COMPLETED) + for task in done: + src = tasks.pop(task) + if task.cancelled(): + cancelled.append(task) + elif exc := task.exception(): + if report.verbose: + traceback.print_exception(type(exc), exc, exc.__traceback__) + report.failed(src, str(exc)) + else: + changed = Changed.YES if task.result() else Changed.NO + # If the file was written back or was successfully checked as + # well-formatted, store this information in the cache. + if write_back is WriteBack.YES or ( + write_back is WriteBack.CHECK and changed is Changed.NO + ): + sources_to_cache.append(src) + report.done(src, changed) + if cancelled: + await asyncio.gather(*cancelled, return_exceptions=True) + if sources_to_cache and not no_cache and cache is not None: + cache.write(sources_to_cache) + finally: + if manager is not None: + manager.shutdown() diff --git a/src/black/const.py b/src/black/const.py new file mode 100644 index 0000000..ee46667 --- /dev/null +++ b/src/black/const.py @@ -0,0 +1,4 @@ +DEFAULT_LINE_LENGTH = 88 +DEFAULT_EXCLUDES = r"/(\.direnv|\.eggs|\.git|\.hg|\.ipynb_checkpoints|\.mypy_cache|\.nox|\.pytest_cache|\.ruff_cache|\.tox|\.svn|\.venv|\.vscode|__pypackages__|_build|buck-out|build|dist|venv)/" # noqa: B950 +DEFAULT_INCLUDES = r"(\.pyi?|\.ipynb)$" +STDIN_PLACEHOLDER = "__BLACK_STDIN_FILENAME__" diff --git a/src/black/debug.py b/src/black/debug.py new file mode 100644 index 0000000..f051c49 --- /dev/null +++ b/src/black/debug.py @@ -0,0 +1,55 @@ +from collections.abc import Iterator +from dataclasses import dataclass, field +from typing import Any, TypeVar, Union + +from black.nodes import Visitor +from black.output import out +from black.parsing import lib2to3_parse +from blib2to3.pgen2 import token +from blib2to3.pytree import Leaf, Node, type_repr + +LN = Union[Leaf, Node] +T = TypeVar("T") + + +@dataclass +class DebugVisitor(Visitor[T]): + tree_depth: int = 0 + list_output: list[str] = field(default_factory=list) + print_output: bool = True + + def out(self, message: str, *args: Any, **kwargs: Any) -> None: + self.list_output.append(message) + if self.print_output: + out(message, *args, **kwargs) + + def visit_default(self, node: LN) -> Iterator[T]: + indent = " " * (2 * self.tree_depth) + if isinstance(node, Node): + _type = type_repr(node.type) + self.out(f"{indent}{_type}", fg="yellow") + self.tree_depth += 1 + for child in node.children: + yield from self.visit(child) + + self.tree_depth -= 1 + self.out(f"{indent}/{_type}", fg="yellow", bold=False) + else: + _type = token.tok_name.get(node.type, str(node.type)) + self.out(f"{indent}{_type}", fg="blue", nl=False) + if node.prefix: + # We don't have to handle prefixes for `Node` objects since + # that delegates to the first child anyway. + self.out(f" {node.prefix!r}", fg="green", bold=False, nl=False) + self.out(f" {node.value!r}", fg="blue", bold=False) + + @classmethod + def show(cls, code: str | Leaf | Node) -> None: + """Pretty-print the lib2to3 AST of a given string of `code`. + + Convenience method for debugging. + """ + v: DebugVisitor[None] = DebugVisitor() + if isinstance(code, str): + code = lib2to3_parse(code) + list(v.visit(code)) diff --git a/src/black/files.py b/src/black/files.py new file mode 100644 index 0000000..a522742 --- /dev/null +++ b/src/black/files.py @@ -0,0 +1,435 @@ +import io +import os +import sys +from collections.abc import Iterable, Iterator, Sequence +from functools import lru_cache +from pathlib import Path +from re import Pattern +from typing import TYPE_CHECKING, Any, Union + +from mypy_extensions import mypyc_attr +from packaging.specifiers import InvalidSpecifier, Specifier, SpecifierSet +from packaging.version import InvalidVersion, Version +from pathspec import GitIgnoreSpec +from pathspec.patterns.gitignore import GitIgnorePatternError + +if sys.version_info >= (3, 11): + try: + import tomllib + except ImportError: + # Help users on older alphas + if not TYPE_CHECKING: + import tomli as tomllib +else: + import tomli as tomllib + +from black.handle_ipynb_magics import jupyter_dependencies_are_installed +from black.mode import TargetVersion +from black.output import err +from black.report import Report + +if TYPE_CHECKING: + import colorama + + +@lru_cache +def _load_toml(path: Path | str) -> dict[str, Any]: + with open(path, "rb") as f: + return tomllib.load(f) + + +@lru_cache +def _cached_resolve(path: Path) -> Path: + return path.resolve() + + +def find_project_root( + srcs: Sequence[str | Path], stdin_filename: str | None = None +) -> tuple[Path, str]: + """Return a directory containing .git, .hg, or pyproject.toml. + + pyproject.toml files are only considered if they contain a [tool.black] + section and are ignored otherwise. + + That directory will be a common parent of all files and directories + passed in `srcs`. + + If no directory in the tree contains a marker that would specify it's the + project root, the root of the file system is returned. + + Returns a two-tuple with the first element as the project root path and + the second element as a string describing the method by which the + project root was discovered. + """ + if stdin_filename is not None: + srcs = tuple(stdin_filename if s == "-" else s for s in srcs) + + if not srcs: + resolved_srcs: tuple[str, ...] = (str(_cached_resolve(Path.cwd())),) + else: + resolved_srcs = tuple( + str(_cached_resolve(Path(Path.cwd(), src))) for src in srcs + ) + + return _find_project_root_cached(resolved_srcs) + + +@lru_cache +def _find_project_root_cached(srcs: tuple[str, ...]) -> tuple[Path, str]: + path_srcs = [Path(src) for src in srcs] + + # A list of lists of parents for each 'src'. 'src' is included as a + # "parent" of itself if it is a directory + src_parents = [ + list(path.parents) + ([path] if path.is_dir() else []) for path in path_srcs + ] + + common_base = max( + set.intersection(*(set(parents) for parents in src_parents)), + key=lambda path: path.parts, + ) + + for directory in (common_base, *common_base.parents): + if (directory / ".git").exists(): + return directory, ".git directory" + + if (directory / ".hg").is_dir(): + return directory, ".hg directory" + + if (directory / "pyproject.toml").is_file(): + pyproject_toml = _load_toml(directory / "pyproject.toml") + if "black" in pyproject_toml.get("tool", {}): + return directory, "pyproject.toml" + + return directory, "file system root" + + +def find_pyproject_toml( + path_search_start: tuple[str, ...], stdin_filename: str | None = None +) -> str | None: + """Find the absolute filepath to a pyproject.toml if it exists""" + path_project_root, _ = find_project_root(path_search_start, stdin_filename) + path_pyproject_toml = path_project_root / "pyproject.toml" + if path_pyproject_toml.is_file(): + return str(path_pyproject_toml) + + try: + path_user_pyproject_toml = find_user_pyproject_toml() + return ( + str(path_user_pyproject_toml) + if path_user_pyproject_toml.is_file() + else None + ) + except (PermissionError, RuntimeError) as e: + # We do not have access to the user-level config directory, so ignore it. + err(f"Ignoring user configuration directory due to {e!r}") + return None + + +@mypyc_attr(patchable=True) +def parse_pyproject_toml(path_config: str) -> dict[str, Any]: + """Parse a pyproject toml file, pulling out relevant parts for Black. + + If parsing fails, will raise a tomllib.TOMLDecodeError. + """ + pyproject_toml = _load_toml(path_config) + config: dict[str, Any] = pyproject_toml.get("tool", {}).get("black", {}) + config = {k.replace("--", "").replace("-", "_"): v for k, v in config.items()} + + if "target_version" not in config: + inferred_target_version = infer_target_version(pyproject_toml) + if inferred_target_version is not None: + config["target_version"] = [v.name.lower() for v in inferred_target_version] + + return config + + +def infer_target_version( + pyproject_toml: dict[str, Any], +) -> list[TargetVersion] | None: + """Infer Black's target version from the project metadata in pyproject.toml. + + Supports the PyPA standard format (PEP 621): + https://packaging.python.org/en/latest/specifications/declaring-project-metadata/#requires-python + + If the target version cannot be inferred, returns None. + """ + project_metadata = pyproject_toml.get("project", {}) + requires_python = project_metadata.get("requires-python", None) + if requires_python is not None: + try: + return parse_req_python_version(requires_python) + except InvalidVersion: + pass + try: + return parse_req_python_specifier(requires_python) + except (InvalidSpecifier, InvalidVersion): + pass + + return None + + +def parse_req_python_version(requires_python: str) -> list[TargetVersion] | None: + """Parse a version string (i.e. ``"3.7"``) to a list of TargetVersion. + + If parsing fails, will raise a packaging.version.InvalidVersion error. + If the parsed version cannot be mapped to a valid TargetVersion, returns None. + """ + version = Version(requires_python) + if version.release[0] != 3: + return None + try: + return [TargetVersion(version.release[1])] + except (IndexError, ValueError): + return None + + +def parse_req_python_specifier(requires_python: str) -> list[TargetVersion] | None: + """Parse a specifier string (i.e. ``">=3.7,<3.10"``) to a list of TargetVersion. + + If parsing fails, will raise a packaging.specifiers.InvalidSpecifier error. + If the parsed specifier cannot be mapped to a valid TargetVersion, returns None. + """ + specifier_set = strip_specifier_set(SpecifierSet(requires_python)) + if not specifier_set: + return None + + target_version_map = {f"3.{v.value}": v for v in TargetVersion} + compatible_versions: list[str] = list(specifier_set.filter(target_version_map)) + if compatible_versions: + return [target_version_map[v] for v in compatible_versions] + return None + + +def strip_specifier_set(specifier_set: SpecifierSet) -> SpecifierSet: + """Strip minor versions for some specifiers in the specifier set. + + For background on version specifiers, see PEP 440: + https://peps.python.org/pep-0440/#version-specifiers + """ + specifiers = [] + for s in specifier_set: + if "*" in str(s): + specifiers.append(s) + elif s.operator in ["~=", "==", ">=", "==="]: + version = Version(s.version) + stripped = Specifier(f"{s.operator}{version.major}.{version.minor}") + specifiers.append(stripped) + elif s.operator == ">": + version = Version(s.version) + if len(version.release) > 2: + s = Specifier(f">={version.major}.{version.minor}") + specifiers.append(s) + else: + specifiers.append(s) + + return SpecifierSet(",".join(str(s) for s in specifiers)) + + +@lru_cache +def find_user_pyproject_toml() -> Path: + r"""Return the path to the top-level user configuration for black. + + This looks for ~\.black on Windows and ~/.config/black on Linux and other + Unix systems. + + May raise: + - RuntimeError: if the current user has no homedir + - PermissionError: if the current process cannot access the user's homedir + """ + if sys.platform == "win32": + # Windows + user_config_path = Path.home() / ".black" + else: + config_root = os.environ.get("XDG_CONFIG_HOME", "~/.config") + user_config_path = Path(config_root).expanduser() / "black" + return _cached_resolve(user_config_path) + + +@lru_cache +def get_gitignore(root: Path) -> GitIgnoreSpec: + """Return a GitIgnoreSpec matching gitignore content if present.""" + gitignore = root / ".gitignore" + lines: list[str] = [] + if gitignore.is_file(): + with gitignore.open(encoding="utf-8") as gf: + lines = gf.readlines() + try: + return GitIgnoreSpec.from_lines(lines) + except GitIgnorePatternError as e: + err(f"Could not parse {gitignore}: {e}") + raise + + +def resolves_outside_root_or_cannot_stat( + path: Path, + root: Path, + report: Report | None = None, +) -> bool: + """ + Returns whether the path is a symbolic link that points outside the + root directory. Also returns True if we failed to resolve the path. + """ + try: + resolved_path = _cached_resolve(path) + except OSError as e: + if report: + report.path_ignored(path, f"cannot be read because {e}") + return True + try: + resolved_path.relative_to(root) + except ValueError: + if report: + report.path_ignored(path, f"is a symbolic link that points outside {root}") + return True + return False + + +def best_effort_relative_path(path: Path, root: Path) -> Path: + # Precondition: resolves_outside_root_or_cannot_stat(path, root) is False + try: + return path.absolute().relative_to(root) + except ValueError: + pass + root_parent = next((p for p in path.parents if _cached_resolve(p) == root), None) + if root_parent is not None: + return path.relative_to(root_parent) + # something adversarial, fallback to path guaranteed by precondition + return _cached_resolve(path).relative_to(root) + + +def _path_is_ignored( + root_relative_path: str, + root: Path, + gitignore_dict: dict[Path, GitIgnoreSpec], +) -> bool: + path = root / root_relative_path + # Note that this logic is sensitive to the ordering of gitignore_dict. Callers must + # ensure that gitignore_dict is ordered from least specific to most specific. + for gitignore_path, pattern in gitignore_dict.items(): + try: + relative_path = path.relative_to(gitignore_path).as_posix() + if path.is_dir(): + relative_path = relative_path + "/" + except ValueError: + break + if pattern.match_file(relative_path): + return True + return False + + +def path_is_excluded( + normalized_path: str, + pattern: Pattern[str] | None, +) -> bool: + match = pattern.search(normalized_path) if pattern else None + return bool(match and match.group(0)) + + +def gen_python_files( + paths: Iterable[Path], + root: Path, + include: Pattern[str], + exclude: Pattern[str], + extend_exclude: Pattern[str] | None, + force_exclude: Pattern[str] | None, + report: Report, + gitignore_dict: dict[Path, GitIgnoreSpec] | None, + *, + verbose: bool, + quiet: bool, +) -> Iterator[Path]: + """Generate all files under `path` whose paths are not excluded by the + `exclude_regex`, `extend_exclude`, or `force_exclude` regexes, + but are included by the `include` regex. + + Symbolic links pointing outside of the `root` directory are ignored. + + `report` is where output about exclusions goes. + """ + + assert root.is_absolute(), f"INTERNAL ERROR: `root` must be absolute but is {root}" + for child in paths: + assert child.is_absolute() + root_relative_path = child.relative_to(root).as_posix() + + # First ignore files matching .gitignore, if passed + if gitignore_dict and _path_is_ignored( + root_relative_path, root, gitignore_dict + ): + report.path_ignored(child, "matches a .gitignore file content") + continue + + # Then ignore with `--exclude` `--extend-exclude` and `--force-exclude` options. + root_relative_path = "/" + root_relative_path + if child.is_dir(): + root_relative_path += "/" + + if path_is_excluded(root_relative_path, exclude): + report.path_ignored(child, "matches the --exclude regular expression") + continue + + if path_is_excluded(root_relative_path, extend_exclude): + report.path_ignored( + child, "matches the --extend-exclude regular expression" + ) + continue + + if path_is_excluded(root_relative_path, force_exclude): + report.path_ignored(child, "matches the --force-exclude regular expression") + continue + + if resolves_outside_root_or_cannot_stat(child, root, report): + continue + + if child.is_dir(): + # If gitignore is None, gitignore usage is disabled, while a Falsey + # gitignore is when the directory doesn't have a .gitignore file. + if gitignore_dict is not None: + new_gitignore_dict = { + **gitignore_dict, + root / child: get_gitignore(child), + } + else: + new_gitignore_dict = None + yield from gen_python_files( + child.iterdir(), + root, + include, + exclude, + extend_exclude, + force_exclude, + report, + new_gitignore_dict, + verbose=verbose, + quiet=quiet, + ) + + elif child.is_file(): + if child.suffix == ".ipynb" and not jupyter_dependencies_are_installed( + warn=verbose or not quiet + ): + continue + include_match = include.search(root_relative_path) if include else True + if include_match: + yield child + + +def wrap_stream_for_windows( + f: io.TextIOWrapper, +) -> Union[io.TextIOWrapper, "colorama.AnsiToWin32"]: + """ + Wrap stream with colorama's wrap_stream so colors are shown on Windows. + + If `colorama` is unavailable, the original stream is returned unmodified. + Otherwise, the `wrap_stream()` function determines whether the stream needs + to be wrapped for a Windows environment and will accordingly either return + an `AnsiToWin32` wrapper or the original stream. + """ + try: + from colorama.initialise import wrap_stream + except ImportError: + return f + else: + # Set `strip=False` to avoid needing to modify test_express_diff_with_color. + return wrap_stream(f, convert=None, strip=False, autoreset=False, wrap=True) diff --git a/src/black/handle_ipynb_magics.py b/src/black/handle_ipynb_magics.py new file mode 100644 index 0000000..e12537d --- /dev/null +++ b/src/black/handle_ipynb_magics.py @@ -0,0 +1,515 @@ +"""Functions to process IPython magics with.""" + +import ast +import collections +import dataclasses +import re +import secrets +import string +from collections.abc import Collection +from functools import lru_cache +from importlib.util import find_spec +from typing import TypeGuard + +from black.mode import Mode +from black.output import out +from black.report import NothingChanged + +TRANSFORMED_MAGICS = frozenset(( + "get_ipython().run_cell_magic", + "get_ipython().system", + "get_ipython().getoutput", + "get_ipython().run_line_magic", +)) +TOKENS_TO_IGNORE = frozenset(( + "ENDMARKER", + "NL", + "NEWLINE", + "COMMENT", + "DEDENT", + "UNIMPORTANT_WS", + "ESCAPED_NL", +)) +PYTHON_CELL_MAGICS = frozenset(( + "capture", + "prun", + "pypy", + "python", + "python3", + "time", + "timeit", +)) + + +@dataclasses.dataclass(frozen=True) +class Replacement: + mask: str + src: str + + +@lru_cache +def jupyter_dependencies_are_installed(*, warn: bool) -> bool: + installed = ( + find_spec("tokenize_rt") is not None and find_spec("IPython") is not None + ) + if not installed and warn: + msg = ( + "Skipping .ipynb files as Jupyter dependencies are not installed.\n" + 'You can fix this by running ``pip install "black[jupyter]"``' + ) + out(msg) + return installed + + +def validate_cell(src: str, mode: Mode) -> None: + r"""Check that cell does not already contain TransformerManager transformations, + or non-Python cell magics, which might cause tokenizer_rt to break because of + indentations. + + If a cell contains ``!ls``, then it'll be transformed to + ``get_ipython().system('ls')``. However, if the cell originally contained + ``get_ipython().system('ls')``, then it would get transformed in the same way: + + >>> TransformerManager().transform_cell("get_ipython().system('ls')") + "get_ipython().system('ls')\n" + >>> TransformerManager().transform_cell("!ls") + "get_ipython().system('ls')\n" + + Due to the impossibility of safely roundtripping in such situations, cells + containing transformed magics will be ignored. + """ + if any(transformed_magic in src for transformed_magic in TRANSFORMED_MAGICS): + raise NothingChanged + + line = _get_code_start(src) + if line.startswith("%%") and ( + line.split(maxsplit=1)[0][2:] + not in PYTHON_CELL_MAGICS | mode.python_cell_magics + ): + raise NothingChanged + + +def remove_trailing_semicolon(src: str) -> tuple[str, bool]: + """Remove trailing semicolon from Jupyter notebook cell. + + For example, + + fig, ax = plt.subplots() + ax.plot(x_data, y_data); # plot data + + would become + + fig, ax = plt.subplots() + ax.plot(x_data, y_data) # plot data + + Mirrors the logic in `quiet` from `IPython.core.displayhook`, but uses + ``tokenize_rt`` so that round-tripping works fine. + """ + from tokenize_rt import reversed_enumerate, src_to_tokens, tokens_to_src + + tokens = src_to_tokens(src) + trailing_semicolon = False + for idx, token in reversed_enumerate(tokens): + if token.name in TOKENS_TO_IGNORE: + continue + if token.name == "OP" and token.src == ";": + del tokens[idx] + trailing_semicolon = True + break + if not trailing_semicolon: + return src, False + return tokens_to_src(tokens), True + + +def put_trailing_semicolon_back(src: str, has_trailing_semicolon: bool) -> str: + """Put trailing semicolon back if cell originally had it. + + Mirrors the logic in `quiet` from `IPython.core.displayhook`, but uses + ``tokenize_rt`` so that round-tripping works fine. + """ + if not has_trailing_semicolon: + return src + from tokenize_rt import reversed_enumerate, src_to_tokens, tokens_to_src + + tokens = src_to_tokens(src) + for idx, token in reversed_enumerate(tokens): + if token.name in TOKENS_TO_IGNORE: + continue + tokens[idx] = token._replace(src=token.src + ";") + break + else: # pragma: nocover + raise AssertionError( + "INTERNAL ERROR: Was not able to reinstate trailing semicolon. " + "Please report a bug on https://github.com/psf/black/issues. " + ) from None + return str(tokens_to_src(tokens)) + + +def mask_cell(src: str) -> tuple[str, list[Replacement]]: + """Mask IPython magics so content becomes parseable Python code. + + For example, + + %matplotlib inline + 'foo' + + becomes + + b"25716f358c32750" + 'foo' + + The replacements are returned, along with the transformed code. + """ + replacements: list[Replacement] = [] + try: + ast.parse(src) + except SyntaxError: + # Might have IPython magics, will process below. + pass + else: + # Syntax is fine, nothing to mask, early return. + return src, replacements + + from IPython.core.inputtransformer2 import TransformerManager + + transformer_manager = TransformerManager() + # A side effect of the following transformation is that it also removes any + # empty lines at the beginning of the cell. + transformed = transformer_manager.transform_cell(src) + transformed, cell_magic_replacements = replace_cell_magics(transformed) + replacements += cell_magic_replacements + transformed = transformer_manager.transform_cell(transformed) + transformed, magic_replacements = replace_magics(transformed) + if len(transformed.strip().splitlines()) != len(src.strip().splitlines()): + # Multi-line magic, not supported. + raise NothingChanged + replacements += magic_replacements + return transformed, replacements + + +def create_token(n_chars: int) -> str: + """Create a randomly generated token that is n_chars characters long.""" + assert n_chars > 0 + if n_chars == 1: + return secrets.choice(string.ascii_letters) + if n_chars < 4: + return "_" + "".join( + secrets.choice(string.ascii_letters + string.digits + "_") + for _ in range(n_chars - 1) + ) + n_bytes = max(n_chars // 2 - 1, 1) + token = secrets.token_hex(n_bytes) + if len(token) + 3 > n_chars: + token = token[:-1] + # We use a bytestring so that the string does not get interpreted + # as a docstring. + return f'b"{token}"' + + +def get_token(src: str, magic: str, existing_tokens: Collection[str] = ()) -> str: + """Return randomly generated token to mask IPython magic with. + + For example, if 'magic' was `%matplotlib inline`, then a possible + token to mask it with would be `"43fdd17f7e5ddc83"`. The token + will be the same length as the magic, and we make sure that it was + not already present anywhere else in the cell. + """ + assert magic + n_chars = len(magic) + token = create_token(n_chars) + counter = 0 + while token in src or token in existing_tokens: + token = create_token(n_chars) + counter += 1 + if counter > 100: + raise AssertionError( + "INTERNAL ERROR: Black was not able to replace IPython magic. " + "Please report a bug on https://github.com/psf/black/issues. " + f"The magic might be helpful: {magic}" + ) from None + return token + + +def replace_cell_magics(src: str) -> tuple[str, list[Replacement]]: + r"""Replace cell magic with token. + + Note that 'src' will already have been processed by IPython's + TransformerManager().transform_cell. + + Example, + + get_ipython().run_cell_magic('t', '-n1', 'ls =!ls\n') + + becomes + + "a794." + ls =!ls + + The replacement, along with the transformed code, is returned. + """ + replacements: list[Replacement] = [] + + tree = ast.parse(src) + + cell_magic_finder = CellMagicFinder() + cell_magic_finder.visit(tree) + if cell_magic_finder.cell_magic is None: + return src, replacements + header = cell_magic_finder.cell_magic.header + mask = get_token(src, header) + replacements.append(Replacement(mask=mask, src=header)) + return f"{mask}\n{cell_magic_finder.cell_magic.body}", replacements + + +def replace_magics(src: str) -> tuple[str, list[Replacement]]: + """Replace magics within body of cell. + + Note that 'src' will already have been processed by IPython's + TransformerManager().transform_cell. + + Example, this + + get_ipython().run_line_magic('matplotlib', 'inline') + 'foo' + + becomes + + "5e67db56d490fd39" + 'foo' + + The replacement, along with the transformed code, are returned. + """ + replacements = [] + existing_tokens: set[str] = set() + magic_finder = MagicFinder() + magic_finder.visit(ast.parse(src)) + new_srcs = [] + for i, line in enumerate(src.split("\n"), start=1): + if i in magic_finder.magics: + offsets_and_magics = magic_finder.magics[i] + if len(offsets_and_magics) != 1: # pragma: nocover + raise AssertionError( + f"Expecting one magic per line, got: {offsets_and_magics}\n" + "Please report a bug on https://github.com/psf/black/issues." + ) + col_offset, magic = ( + offsets_and_magics[0].col_offset, + offsets_and_magics[0].magic, + ) + mask = get_token(src, magic, existing_tokens) + replacements.append(Replacement(mask=mask, src=magic)) + existing_tokens.add(mask) + line = line[:col_offset] + mask + new_srcs.append(line) + return "\n".join(new_srcs), replacements + + +def unmask_cell(src: str, replacements: list[Replacement]) -> str: + """Remove replacements from cell. + + For example + + "9b20" + foo = bar + + becomes + + %%time + foo = bar + """ + for replacement in replacements: + if src.count(replacement.mask) != 1: + raise NothingChanged + src = src.replace(replacement.mask, replacement.src, 1) + return src + + +def _get_code_start(src: str) -> str: + """Provides the first line where the code starts. + + Iterates over lines of code until it finds the first line that doesn't + contain only empty spaces and comments. It removes any empty spaces at the + start of the line and returns it. If such line doesn't exist, it returns an + empty string. + """ + for match in re.finditer(".+", src): + line = match.group(0).lstrip() + if line and not line.startswith("#"): + return line + return "" + + +def _is_ipython_magic(node: ast.expr) -> TypeGuard[ast.Attribute]: + """Check if attribute is IPython magic. + + Note that the source of the abstract syntax tree + will already have been processed by IPython's + TransformerManager().transform_cell. + """ + return ( + isinstance(node, ast.Attribute) + and isinstance(node.value, ast.Call) + and isinstance(node.value.func, ast.Name) + and node.value.func.id == "get_ipython" + ) + + +def _get_str_args(args: list[ast.expr]) -> list[str]: + str_args = [] + for arg in args: + assert isinstance(arg, ast.Constant) and isinstance(arg.value, str) + str_args.append(arg.value) + return str_args + + +@dataclasses.dataclass(frozen=True) +class CellMagic: + name: str + params: str | None + body: str + + @property + def header(self) -> str: + if self.params: + return f"%%{self.name} {self.params}" + return f"%%{self.name}" + + +# ast.NodeVisitor + dataclass = breakage under mypyc. +class CellMagicFinder(ast.NodeVisitor): + r"""Find cell magics. + + Note that the source of the abstract syntax tree + will already have been processed by IPython's + TransformerManager().transform_cell. + + For example, + + %%time\n + foo() + + would have been transformed to + + get_ipython().run_cell_magic('time', '', 'foo()\n') + + and we look for instances of the latter. + """ + + def __init__(self, cell_magic: CellMagic | None = None) -> None: + self.cell_magic = cell_magic + + def visit_Expr(self, node: ast.Expr) -> None: + """Find cell magic, extract header and body.""" + if ( + isinstance(node.value, ast.Call) + and _is_ipython_magic(node.value.func) + and node.value.func.attr == "run_cell_magic" + ): + args = _get_str_args(node.value.args) + self.cell_magic = CellMagic(name=args[0], params=args[1], body=args[2]) + self.generic_visit(node) + + +@dataclasses.dataclass(frozen=True) +class OffsetAndMagic: + col_offset: int + magic: str + + +# Unsurprisingly, subclassing ast.NodeVisitor means we can't use dataclasses here +# as mypyc will generate broken code. +class MagicFinder(ast.NodeVisitor): + """Visit cell to look for get_ipython calls. + + Note that the source of the abstract syntax tree + will already have been processed by IPython's + TransformerManager().transform_cell. + + For example, + + %matplotlib inline + + would have been transformed to + + get_ipython().run_line_magic('matplotlib', 'inline') + + and we look for instances of the latter (and likewise for other + types of magics). + """ + + def __init__(self) -> None: + self.magics: dict[int, list[OffsetAndMagic]] = collections.defaultdict(list) + + def visit_Assign(self, node: ast.Assign) -> None: + """Look for system assign magics. + + For example, + + black_version = !black --version + env = %env var + + would have been (respectively) transformed to + + black_version = get_ipython().getoutput('black --version') + env = get_ipython().run_line_magic('env', 'var') + + and we look for instances of any of the latter. + """ + if isinstance(node.value, ast.Call) and _is_ipython_magic(node.value.func): + args = _get_str_args(node.value.args) + if node.value.func.attr == "getoutput": + src = f"!{args[0]}" + elif node.value.func.attr == "run_line_magic": + src = f"%{args[0]}" + if args[1]: + src += f" {args[1]}" + else: + raise AssertionError( + f"Unexpected IPython magic {node.value.func.attr!r} found. " + "Please report a bug on https://github.com/psf/black/issues." + ) from None + self.magics[node.value.lineno].append( + OffsetAndMagic(node.value.col_offset, src) + ) + self.generic_visit(node) + + def visit_Expr(self, node: ast.Expr) -> None: + """Look for magics in body of cell. + + For examples, + + !ls + !!ls + ?ls + ??ls + + would (respectively) get transformed to + + get_ipython().system('ls') + get_ipython().getoutput('ls') + get_ipython().run_line_magic('pinfo', 'ls') + get_ipython().run_line_magic('pinfo2', 'ls') + + and we look for instances of any of the latter. + """ + if isinstance(node.value, ast.Call) and _is_ipython_magic(node.value.func): + args = _get_str_args(node.value.args) + if node.value.func.attr == "run_line_magic": + if args[0] == "pinfo": + src = f"?{args[1]}" + elif args[0] == "pinfo2": + src = f"??{args[1]}" + else: + src = f"%{args[0]}" + if args[1]: + src += f" {args[1]}" + elif node.value.func.attr == "system": + src = f"!{args[0]}" + elif node.value.func.attr == "getoutput": + src = f"!!{args[0]}" + else: + raise NothingChanged # unsupported magic. + self.magics[node.value.lineno].append( + OffsetAndMagic(node.value.col_offset, src) + ) + self.generic_visit(node) diff --git a/src/black/linegen.py b/src/black/linegen.py new file mode 100644 index 0000000..c9db9d8 --- /dev/null +++ b/src/black/linegen.py @@ -0,0 +1,2198 @@ +""" +Generating lines of code. +""" + +import re +import sys +from collections.abc import Collection, Iterator +from dataclasses import replace +from enum import Enum, auto +from functools import partial, wraps +from typing import Union, cast + +from black.brackets import ( + COMMA_PRIORITY, + COMPARATOR_PRIORITY, + DOT_PRIORITY, + STRING_PRIORITY, + get_leaves_inside_matching_brackets, + max_delimiter_priority_in_atom, +) +from black.comments import ( + FMT_OFF, + FMT_ON, + contains_fmt_directive, + generate_comments, + list_comments, +) +from black.lines import ( + Line, + RHSResult, + append_leaves, + can_be_split, + can_omit_invisible_parens, + is_line_short_enough, + line_to_string, +) +from black.mode import Feature, Mode, Preview +from black.nodes import ( + ASSIGNMENTS, + BRACKETS, + CLOSING_BRACKETS, + OPENING_BRACKETS, + STANDALONE_COMMENT, + STATEMENT, + WHITESPACE, + Visitor, + ensure_visible, + fstring_tstring_to_string, + get_annotation_type, + has_sibling_with_type, + is_arith_like, + is_async_stmt_or_funcdef, + is_atom_with_invisible_parens, + is_docstring, + is_empty_tuple, + is_generator, + is_lpar_token, + is_multiline_string, + is_name_token, + is_one_sequence_between, + is_one_tuple, + is_parent_function_or_class, + is_part_of_annotation, + is_rpar_token, + is_stub_body, + is_stub_suite, + is_tuple, + is_tuple_containing_star, + is_tuple_containing_walrus, + is_type_ignore_comment_string, + is_vararg, + is_walrus_assignment, + is_yield, + syms, + wrap_in_parentheses, +) +from black.numerics import normalize_numeric_literal +from black.strings import ( + fix_multiline_docstring, + get_string_prefix, + normalize_string_prefix, + normalize_string_quotes, + normalize_unicode_escape_sequences, + str_width, +) +from black.trans import ( + CannotTransform, + StringMerger, + StringParenStripper, + StringParenWrapper, + StringSplitter, + Transformer, + hug_power_op, +) +from blib2to3.pgen2 import token +from blib2to3.pytree import Leaf, Node + +# types +LeafID = int +LN = Union[Leaf, Node] + + +class CannotSplit(CannotTransform): + """A readable split that fits the allotted line length is impossible.""" + + +# This isn't a dataclass because @dataclass + Generic breaks mypyc. +# See also https://github.com/mypyc/mypyc/issues/827. +class LineGenerator(Visitor[Line]): + """Generates reformatted Line objects. Empty lines are not emitted. + + Note: destroys the tree it's visiting by mutating prefixes of its leaves + in ways that will no longer stringify to valid Python code on the tree. + """ + + def __init__(self, mode: Mode, features: Collection[Feature]) -> None: + self.mode = mode + self.features = features + self.current_line: Line + self.__post_init__() + + def line(self, indent: int = 0) -> Iterator[Line]: + """Generate a line. + + If the line is empty, only emit if it makes sense. + If the line is too long, split it first and then generate. + + If any lines were generated, set up a new current_line. + """ + if not self.current_line: + self.current_line.depth += indent + return # Line is empty, don't emit. Creating a new one unnecessary. + + if len(self.current_line.leaves) == 1 and is_async_stmt_or_funcdef( + self.current_line.leaves[0] + ): + # Special case for async def/for/with statements. `visit_async_stmt` + # adds an `ASYNC` leaf then visits the child def/for/with statement + # nodes. Line yields from those nodes shouldn't treat the former + # `ASYNC` leaf as a complete line. + return + + complete_line = self.current_line + self.current_line = Line(mode=self.mode, depth=complete_line.depth + indent) + yield complete_line + + def visit_default(self, node: LN) -> Iterator[Line]: + """Default `visit_*()` implementation. Recurses to children of `node`.""" + if isinstance(node, Leaf): + any_open_brackets = self.current_line.bracket_tracker.any_open_brackets() + for comment in generate_comments(node, mode=self.mode): + if any_open_brackets: + # any comment within brackets is subject to splitting + self.current_line.append(comment) + elif comment.type == token.COMMENT: + # regular trailing comment + self.current_line.append(comment) + yield from self.line() + + else: + # regular standalone comment + yield from self.line() + + self.current_line.append(comment) + yield from self.line() + + if any_open_brackets: + node.prefix = "" + if node.type not in WHITESPACE: + self.current_line.append(node) + yield from super().visit_default(node) + + def visit_test(self, node: Node) -> Iterator[Line]: + """Visit an `x if y else z` test""" + + already_parenthesized = ( + node.prev_sibling and node.prev_sibling.type == token.LPAR + ) + + if not already_parenthesized: + # Similar to logic in wrap_in_parentheses + lpar = Leaf(token.LPAR, "") + rpar = Leaf(token.RPAR, "") + prefix = node.prefix + node.prefix = "" + lpar.prefix = prefix + node.insert_child(0, lpar) + node.append_child(rpar) + + yield from self.visit_default(node) + + def visit_INDENT(self, node: Leaf) -> Iterator[Line]: + """Increase indentation level, maybe yield a line.""" + # In blib2to3 INDENT never holds comments. + yield from self.line(+1) + yield from self.visit_default(node) + + def visit_DEDENT(self, node: Leaf) -> Iterator[Line]: + """Decrease indentation level, maybe yield a line.""" + # The current line might still wait for trailing comments. At DEDENT time + # there won't be any (they would be prefixes on the preceding NEWLINE). + # Emit the line then. + yield from self.line() + + # While DEDENT has no value, its prefix may contain standalone comments + # that belong to the current indentation level. Get 'em. + yield from self.visit_default(node) + + # Finally, emit the dedent. + yield from self.line(-1) + + def visit_stmt( + self, node: Node, keywords: set[str], parens: set[str] + ) -> Iterator[Line]: + """Visit a statement. + + This implementation is shared for `if`, `while`, `for`, `try`, `except`, + `def`, `with`, `class`, `assert`, and assignments. + + The relevant Python language `keywords` for a given statement will be + NAME leaves within it. This methods puts those on a separate line. + + `parens` holds a set of string leaf values immediately after which + invisible parens should be put. + """ + normalize_invisible_parens( + node, parens_after=parens, mode=self.mode, features=self.features + ) + for child in node.children: + if is_name_token(child) and child.value in keywords: + yield from self.line() + + yield from self.visit(child) + + def visit_typeparams(self, node: Node) -> Iterator[Line]: + yield from self.visit_default(node) + node.children[0].prefix = "" + + def visit_typevartuple(self, node: Node) -> Iterator[Line]: + yield from self.visit_default(node) + node.children[1].prefix = "" + + def visit_paramspec(self, node: Node) -> Iterator[Line]: + yield from self.visit_default(node) + node.children[1].prefix = "" + + def visit_dictsetmaker(self, node: Node) -> Iterator[Line]: + if Preview.wrap_long_dict_values_in_parens in self.mode: + for i, child in enumerate(node.children): + if i == 0: + continue + if node.children[i - 1].type == token.COLON: + if ( + child.type == syms.atom + and child.children[0].type in OPENING_BRACKETS + and not is_walrus_assignment(child) + ): + maybe_make_parens_invisible_in_atom( + child, + parent=node, + mode=self.mode, + features=self.features, + remove_brackets_around_comma=False, + ) + else: + wrap_in_parentheses(node, child, visible=False, index=i) + yield from self.visit_default(node) + + def visit_funcdef(self, node: Node) -> Iterator[Line]: + """Visit function definition.""" + yield from self.line() + + # Remove redundant brackets around return type annotation. + is_return_annotation = False + for child in node.children: + if child.type == token.RARROW: + is_return_annotation = True + elif is_return_annotation: + if child.type == syms.atom and child.children[0].type == token.LPAR: + if maybe_make_parens_invisible_in_atom( + child, + parent=node, + mode=self.mode, + features=self.features, + remove_brackets_around_comma=False, + ): + wrap_in_parentheses(node, child, visible=False) + else: + wrap_in_parentheses(node, child, visible=False) + is_return_annotation = False + + for child in node.children: + yield from self.visit(child) + + def visit_match_case(self, node: Node) -> Iterator[Line]: + """Visit either a match or case statement.""" + normalize_invisible_parens( + node, parens_after=set(), mode=self.mode, features=self.features + ) + + yield from self.line() + for child in node.children: + yield from self.visit(child) + + def visit_suite(self, node: Node) -> Iterator[Line]: + """Visit a suite.""" + if is_stub_suite(node): + yield from self.visit(node.children[2]) + else: + yield from self.visit_default(node) + + def visit_simple_stmt(self, node: Node) -> Iterator[Line]: + """Visit a statement without nested statements.""" + prev_type: int | None = None + for i, child in enumerate(node.children): + if (prev_type is None or prev_type == token.SEMI) and is_arith_like(child): + wrap_in_parentheses(node, child, visible=False, index=i) + prev_type = child.type + + if node.parent and node.parent.type in STATEMENT: + if is_parent_function_or_class(node) and is_stub_body(node): + yield from self.visit_default(node) + else: + yield from self.line(+1) + yield from self.visit_default(node) + yield from self.line(-1) + + else: + if node.parent and is_stub_suite(node.parent): + node.prefix = "" + yield from self.visit_default(node) + return + yield from self.line() + yield from self.visit_default(node) + + def visit_async_stmt(self, node: Node) -> Iterator[Line]: + """Visit `async def`, `async for`, `async with`.""" + yield from self.line() + + children = iter(node.children) + for child in children: + yield from self.visit(child) + + if child.type == token.ASYNC or child.type == STANDALONE_COMMENT: + # STANDALONE_COMMENT happens when `# fmt: skip` is applied on the async + # line. + break + + internal_stmt = next(children) + yield from self.visit(internal_stmt) + + def visit_decorators(self, node: Node) -> Iterator[Line]: + """Visit decorators.""" + for child in node.children: + yield from self.line() + yield from self.visit(child) + + def visit_power(self, node: Node) -> Iterator[Line]: + for idx, leaf in enumerate(node.children[:-1]): + next_leaf = node.children[idx + 1] + + if not isinstance(leaf, Leaf): + continue + + value = leaf.value.lower() + if ( + leaf.type == token.NUMBER + and next_leaf.type == syms.trailer + # Ensure that we are in an attribute trailer + and next_leaf.children[0].type == token.DOT + # It shouldn't wrap hexadecimal, binary and octal literals + and not value.startswith(("0x", "0b", "0o")) + # It shouldn't wrap complex literals + and "j" not in value + ): + wrap_in_parentheses(node, leaf) + + remove_await_parens(node, mode=self.mode, features=self.features) + + yield from self.visit_default(node) + + def visit_SEMI(self, leaf: Leaf) -> Iterator[Line]: + """Remove a semicolon and put the other statement on a separate line.""" + yield from self.line() + + def visit_ENDMARKER(self, leaf: Leaf) -> Iterator[Line]: + """End of file. Process outstanding comments and end with a newline.""" + yield from self.visit_default(leaf) + yield from self.line() + + def visit_STANDALONE_COMMENT(self, leaf: Leaf) -> Iterator[Line]: + any_open_brackets = self.current_line.bracket_tracker.any_open_brackets() + if not any_open_brackets: + yield from self.line() + # STANDALONE_COMMENT nodes created by our special handling in + # normalize_fmt_off for comment-only blocks have fmt:off as the first + # line and fmt:on as the last line (each directive on its own line, + # not embedded in other text). These should be appended directly + # without calling visit_default, which would process their prefix and + # lose indentation. Normal STANDALONE_COMMENT nodes go through + # visit_default. + value = leaf.value + lines = value.splitlines() + is_fmt_off_block = ( + len(lines) >= 2 + and contains_fmt_directive(lines[0], FMT_OFF) + and contains_fmt_directive(lines[-1], FMT_ON) + ) + if is_fmt_off_block: + is_after_invisible_lpar = ( + leaf.fmt_pass_converted_first_leaf is None + and len(self.current_line.leaves) == 1 + and self.current_line.leaves[0].type == token.LPAR + and not self.current_line.leaves[0].value + ) + # This is a fmt:off/on block from normalize_fmt_off - we still need + # to process any prefix comments (like markdown comments) but append + # the fmt block itself directly to preserve its formatting + + # Only process prefix comments if there actually is a prefix with comments + if leaf.prefix and any( + line.strip().startswith("#") + and not contains_fmt_directive(line.strip()) + for line in leaf.prefix.split("\n") + ): + for comment in generate_comments(leaf, mode=self.mode): + yield from self.line() + self.current_line.append(comment) + yield from self.line() + # Clear the prefix since we've processed it as comments above + leaf.prefix = "" + + self.current_line.append(leaf) + if not any_open_brackets or is_after_invisible_lpar: + yield from self.line() + else: + # Normal standalone comment - process through visit_default + yield from self.visit_default(leaf) + + def visit_factor(self, node: Node) -> Iterator[Line]: + """Force parentheses between a unary op and a binary power: + + -2 ** 8 -> -(2 ** 8) + """ + _operator, operand = node.children + if ( + operand.type == syms.power + and len(operand.children) == 3 + and operand.children[1].type == token.DOUBLESTAR + ): + lpar = Leaf(token.LPAR, "(") + rpar = Leaf(token.RPAR, ")") + index = operand.remove() or 0 + node.insert_child(index, Node(syms.atom, [lpar, operand, rpar])) + yield from self.visit_default(node) + + def visit_tname(self, node: Node) -> Iterator[Line]: + """ + Add potential parentheses around types in function parameter lists to be made + into real parentheses in case the type hint is too long to fit on a line + Examples: + def foo(a: int, b: float = 7): ... + + -> + + def foo(a: (int), b: (float) = 7): ... + """ + if len(node.children) == 3 and maybe_make_parens_invisible_in_atom( + node.children[2], parent=node, mode=self.mode, features=self.features + ): + wrap_in_parentheses(node, node.children[2], visible=False) + + yield from self.visit_default(node) + + def visit_STRING(self, leaf: Leaf) -> Iterator[Line]: + normalize_unicode_escape_sequences(leaf) + + if is_docstring(leaf) and not re.search(r"\\\s*\n", leaf.value): + # We're ignoring docstrings with backslash newline escapes because changing + # indentation of those changes the AST representation of the code. + if self.mode.string_normalization: + docstring = normalize_string_prefix(leaf.value) + # We handle string normalization at the end of this method, but since + # what we do right now acts differently depending on quote style (ex. + # see padding logic below), there's a possibility for unstable + # formatting. To avoid a situation where this function formats a + # docstring differently on the second pass, normalize it early. + docstring = normalize_string_quotes(docstring) + else: + docstring = leaf.value + prefix = get_string_prefix(docstring) + docstring = docstring[len(prefix) :] # Remove the prefix + quote_char = docstring[0] + # A natural way to remove the outer quotes is to do: + # docstring = docstring.strip(quote_char) + # but that breaks on """""x""" (which is '""x'). + # So we actually need to remove the first character and the next two + # characters but only if they are the same as the first. + quote_len = 1 if docstring[1] != quote_char else 3 + docstring = docstring[quote_len:-quote_len] + docstring_started_empty = not docstring + indent = " " * 4 * self.current_line.depth + + if is_multiline_string(leaf): + docstring = fix_multiline_docstring(docstring, indent) + else: + docstring = docstring.strip() + + has_trailing_backslash = False + if docstring: + # Add some padding if the docstring starts / ends with a quote mark. + if docstring[0] == quote_char: + docstring = " " + docstring + if docstring[-1] == quote_char: + docstring += " " + if docstring[-1] == "\\": + backslash_count = len(docstring) - len(docstring.rstrip("\\")) + if backslash_count % 2: + # Odd number of tailing backslashes, add some padding to + # avoid escaping the closing string quote. + docstring += " " + has_trailing_backslash = True + elif not docstring_started_empty: + docstring = " " + + # We could enforce triple quotes at this point. + quote = quote_char * quote_len + + # It's invalid to put closing single-character quotes on a new line. + if quote_len == 3: + # We need to find the length of the last line of the docstring + # to find if we can add the closing quotes to the line without + # exceeding the maximum line length. + # If docstring is one line, we don't put the closing quotes on a + # separate line because it looks ugly (#3320). + lines = docstring.splitlines() + last_line_length = len(lines[-1]) if docstring else 0 + + # If adding closing quotes would cause the last line to exceed + # the maximum line length, and the closing quote is not + # prefixed by a newline then put a line break before + # the closing quotes + if ( + len(lines) > 1 + and last_line_length + quote_len > self.mode.line_length + and len(indent) + quote_len <= self.mode.line_length + and not has_trailing_backslash + ): + if leaf.value[-1 - quote_len] == "\n": + leaf.value = prefix + quote + docstring + quote + else: + leaf.value = prefix + quote + docstring + "\n" + indent + quote + else: + leaf.value = prefix + quote + docstring + quote + else: + leaf.value = prefix + quote + docstring + quote + + if self.mode.string_normalization and leaf.type == token.STRING: + leaf.value = normalize_string_prefix(leaf.value) + leaf.value = normalize_string_quotes(leaf.value) + yield from self.visit_default(leaf) + + def visit_NUMBER(self, leaf: Leaf) -> Iterator[Line]: + normalize_numeric_literal(leaf) + yield from self.visit_default(leaf) + + def visit_atom(self, node: Node) -> Iterator[Line]: + """Visit any atom""" + if len(node.children) == 3: + first = node.children[0] + last = node.children[-1] + if (first.type == token.LSQB and last.type == token.RSQB) or ( + first.type == token.LBRACE and last.type == token.RBRACE + ): + # Lists or sets of one item + maybe_make_parens_invisible_in_atom( + node.children[1], + parent=node, + mode=self.mode, + features=self.features, + ) + + yield from self.visit_default(node) + + def visit_fstring(self, node: Node) -> Iterator[Line]: + # If the fstring was converted to a STANDALONE_COMMENT by + # normalize_fmt_off (e.g. it was inside a # fmt: off block), + # skip the fstring-to-string conversion and just visit normally. + if any(child.type == STANDALONE_COMMENT for child in node.children): + yield from self.visit_default(node) + return + # currently we don't want to format and split f-strings at all. + string_leaf = fstring_tstring_to_string(node) + node.replace(string_leaf) + if "\\" in string_leaf.value and any( + "\\" in str(child) + for child in node.children + if child.type == syms.fstring_replacement_field + ): + # string normalization doesn't account for nested quotes, + # causing breakages. skip normalization when nested quotes exist + yield from self.visit_default(string_leaf) + return + yield from self.visit_STRING(string_leaf) + + def visit_tstring(self, node: Node) -> Iterator[Line]: + # If the tstring was converted to a STANDALONE_COMMENT by + # normalize_fmt_off, skip the conversion and just visit normally. + if any(child.type == STANDALONE_COMMENT for child in node.children): + yield from self.visit_default(node) + return + # currently we don't want to format and split t-strings at all. + string_leaf = fstring_tstring_to_string(node) + node.replace(string_leaf) + if "\\" in string_leaf.value and any( + "\\" in str(child) + for child in node.children + if child.type == syms.fstring_replacement_field + ): + # string normalization doesn't account for nested quotes, + # causing breakages. skip normalization when nested quotes exist + yield from self.visit_default(string_leaf) + return + yield from self.visit_STRING(string_leaf) + + # TODO: Uncomment Implementation to format f-string children + # fstring_start = node.children[0] + # fstring_end = node.children[-1] + # assert isinstance(fstring_start, Leaf) + # assert isinstance(fstring_end, Leaf) + + # quote_char = fstring_end.value[0] + # quote_idx = fstring_start.value.index(quote_char) + # prefix, quote = ( + # fstring_start.value[:quote_idx], + # fstring_start.value[quote_idx:] + # ) + + # if not is_docstring(node, self.mode): + # prefix = normalize_string_prefix(prefix) + + # assert quote == fstring_end.value + + # is_raw_fstring = "r" in prefix or "R" in prefix + # middles = [ + # leaf + # for leaf in node.leaves() + # if leaf.type == token.FSTRING_MIDDLE + # ] + + # if self.mode.string_normalization: + # middles, quote = normalize_fstring_quotes(quote, middles, is_raw_fstring) + + # fstring_start.value = prefix + quote + # fstring_end.value = quote + + # yield from self.visit_default(node) + + def visit_comp_for(self, node: Node) -> Iterator[Line]: + if Preview.wrap_comprehension_in in self.mode: + normalize_invisible_parens( + node, parens_after={"in"}, mode=self.mode, features=self.features + ) + yield from self.visit_default(node) + + def visit_old_comp_for(self, node: Node) -> Iterator[Line]: + yield from self.visit_comp_for(node) + + def __post_init__(self) -> None: + """You are in a twisty little maze of passages.""" + self.current_line = Line(mode=self.mode) + + v = self.visit_stmt + Ø: set[str] = set() + self.visit_assert_stmt = partial(v, keywords={"assert"}, parens={"assert", ","}) + self.visit_if_stmt = partial( + v, keywords={"if", "else", "elif"}, parens={"if", "elif"} + ) + self.visit_while_stmt = partial(v, keywords={"while", "else"}, parens={"while"}) + self.visit_for_stmt = partial(v, keywords={"for", "else"}, parens={"for", "in"}) + self.visit_try_stmt = partial( + v, keywords={"try", "except", "else", "finally"}, parens=Ø + ) + self.visit_except_clause = partial(v, keywords={"except"}, parens={"except"}) + self.visit_with_stmt = partial(v, keywords={"with"}, parens={"with"}) + self.visit_classdef = partial(v, keywords={"class"}, parens=Ø) + + self.visit_expr_stmt = partial(v, keywords=Ø, parens=ASSIGNMENTS) + self.visit_return_stmt = partial(v, keywords={"return"}, parens={"return"}) + self.visit_yield_expr = partial( + v, + keywords=Ø, + parens=( + {"yield"} if Preview.parenthesize_tuple_in_yield in self.mode else Ø + ), + ) + self.visit_import_from = partial(v, keywords=Ø, parens={"import"}) + self.visit_del_stmt = partial(v, keywords=Ø, parens={"del"}) + self.visit_async_funcdef = self.visit_async_stmt + self.visit_decorated = self.visit_decorators + + # PEP 634 + self.visit_match_stmt = self.visit_match_case + self.visit_case_block = self.visit_match_case + self.visit_guard = partial(v, keywords=Ø, parens={"if"}) + + +# Remove when `simplify_power_operator_hugging` becomes stable. +def _hugging_power_ops_line_to_string( + line: Line, + features: Collection[Feature], + mode: Mode, +) -> str | None: + try: + return line_to_string(next(hug_power_op(line, features, mode))) + except CannotTransform: + return None + + +def transform_line( + line: Line, mode: Mode, features: Collection[Feature] = () +) -> Iterator[Line]: + """Transform a `line`, potentially splitting it into many lines. + + They should fit in the allotted `line_length` but might not be able to. + + `features` are syntactical features that may be used in the output. + """ + if line.is_comment: + yield line + return + + line_str = line_to_string(line) + + if Preview.simplify_power_operator_hugging in mode: + line_str_hugging_power_ops = line_str + else: + # We need the line string when power operators are hugging to determine if we + # should split the line. Default to line_str, if no power operator are present + # on the line. + line_str_hugging_power_ops = ( + _hugging_power_ops_line_to_string(line, features, mode) or line_str + ) + + ll = mode.line_length + sn = mode.string_normalization + string_merge = StringMerger(ll, sn) + string_paren_strip = StringParenStripper(ll, sn) + string_split = StringSplitter(ll, sn) + string_paren_wrap = StringParenWrapper(ll, sn) + + transformers: list[Transformer] + if ( + not line.contains_uncollapsable_type_comments() + and not line.should_split_rhs + and not line.magic_trailing_comma + and ( + is_line_short_enough(line, mode=mode, line_str=line_str_hugging_power_ops) + or line.contains_unsplittable_type_ignore() + ) + and not (line.inside_brackets and line.contains_standalone_comments()) + and not line.contains_implicit_multiline_string_with_comments() + ): + # Only apply basic string preprocessing, since lines shouldn't be split here. + if Preview.string_processing in mode: + transformers = [string_merge, string_paren_strip] + else: + transformers = [] + elif line.is_def and not should_split_funcdef_with_rhs(line, mode): + transformers = [left_hand_split] + else: + + def _rhs( + self: object, line: Line, features: Collection[Feature], mode: Mode + ) -> Iterator[Line]: + """Wraps calls to `right_hand_split`. + + The calls increasingly `omit` right-hand trailers (bracket pairs with + content), meaning the trailers get glued together to split on another + bracket pair instead. + """ + for omit in generate_trailers_to_omit(line, mode.line_length): + lines = list(right_hand_split(line, mode, features, omit=omit)) + # Note: this check is only able to figure out if the first line of the + # *current* transformation fits in the line length. This is true only + # for simple cases. All others require running more transforms via + # `transform_line()`. This check doesn't know if those would succeed. + if is_line_short_enough(lines[0], mode=mode) or ( + omit and _over_length_only_due_to_subscript_comment(lines[0], mode) + ): + yield from lines + return + + # All splits failed, best effort split with no omits. + # This mostly happens to multiline strings that are by definition + # reported as not fitting a single line, as well as lines that contain + # trailing commas (those have to be exploded). + yield from right_hand_split(line, mode, features=features) + + # HACK: nested functions (like _rhs) compiled by mypyc don't retain their + # __name__ attribute which is needed in `run_transformer` further down. + # Unfortunately a nested class breaks mypyc too. So a class must be created + # via type ... https://github.com/mypyc/mypyc/issues/884 + rhs = type("rhs", (), {"__call__": _rhs})() + + if Preview.string_processing in mode: + if line.inside_brackets: + transformers = [ + string_merge, + string_paren_strip, + string_split, + delimiter_split, + standalone_comment_split, + string_paren_wrap, + rhs, + ] + else: + transformers = [ + string_merge, + string_paren_strip, + string_split, + string_paren_wrap, + rhs, + ] + else: + if line.inside_brackets: + transformers = [delimiter_split, standalone_comment_split, rhs] + else: + transformers = [rhs] + + if Preview.simplify_power_operator_hugging not in mode: + # It's always safe to attempt hugging of power operations and pretty much every + # line could match. + transformers.append(hug_power_op) + + for transform in transformers: + # We are accumulating lines in `result` because we might want to abort + # mission and return the original line in the end, or attempt a different + # split altogether. + try: + result = run_transformer(line, transform, mode, features, line_str=line_str) + except CannotTransform: + continue + else: + yield from result + break + + else: + # A leftover standalone comment would render inline and break the + # second pass with a parse error (#4296). Force a split so the + # output is at least valid Python. + if line.contains_standalone_comments(): + yield from _force_standalone_comment_split(line) + else: + yield line + + +def should_split_funcdef_with_rhs(line: Line, mode: Mode) -> bool: + """If a funcdef has a magic trailing comma in the return type, then we should first + split the line with rhs to respect the comma. + """ + return_type_leaves: list[Leaf] = [] + in_return_type = False + + for leaf in line.leaves: + if leaf.type == token.COLON: + in_return_type = False + if in_return_type: + return_type_leaves.append(leaf) + if leaf.type == token.RARROW: + in_return_type = True + + # using `bracket_split_build_line` will mess with whitespace, so we duplicate a + # couple lines from it. + result = Line(mode=line.mode, depth=line.depth) + leaves_to_track = get_leaves_inside_matching_brackets(return_type_leaves) + for leaf in return_type_leaves: + result.append( + leaf, + preformatted=True, + track_bracket=id(leaf) in leaves_to_track, + ) + + # we could also return true if the line is too long, and the return type is longer + # than the param list. Or if `should_split_rhs` returns True. + return result.magic_trailing_comma is not None + + +class _BracketSplitComponent(Enum): + head = auto() + body = auto() + tail = auto() + + +def left_hand_split( + line: Line, _features: Collection[Feature], mode: Mode +) -> Iterator[Line]: + """Split line into many lines, starting with the first matching bracket pair. + + Note: this usually looks weird, only use this for function definitions. + Prefer RHS otherwise. This is why this function is not symmetrical with + :func:`right_hand_split` which also handles optional parentheses. + """ + for leaf_type in [token.LPAR, token.LSQB]: + tail_leaves: list[Leaf] = [] + body_leaves: list[Leaf] = [] + head_leaves: list[Leaf] = [] + current_leaves = head_leaves + matching_bracket: Leaf | None = None + depth = 0 + for index, leaf in enumerate(line.leaves): + if index == 2 and leaf.type == token.LSQB: + # A [ at index 2 means this is a type param, so start + # tracking the depth + depth += 1 + elif depth > 0: + if leaf.type == token.LSQB: + depth += 1 + elif leaf.type == token.RSQB: + depth -= 1 + if ( + current_leaves is body_leaves + and leaf.type in CLOSING_BRACKETS + and leaf.opening_bracket is matching_bracket + and isinstance(matching_bracket, Leaf) + # If the code is still on LPAR and we are inside a type + # param, ignore the match since this is searching + # for the function arguments + and not (leaf_type == token.LPAR and depth > 0) + ): + ensure_visible(leaf) + ensure_visible(matching_bracket) + current_leaves = tail_leaves if body_leaves else head_leaves + current_leaves.append(leaf) + if current_leaves is head_leaves: + if leaf.type == leaf_type and ( + not (leaf_type == token.LPAR and depth > 0) + ): + matching_bracket = leaf + current_leaves = body_leaves + if matching_bracket and tail_leaves: + break + if not matching_bracket or not tail_leaves: + raise CannotSplit("No brackets found") + + head = bracket_split_build_line( + head_leaves, line, matching_bracket, component=_BracketSplitComponent.head + ) + body = bracket_split_build_line( + body_leaves, line, matching_bracket, component=_BracketSplitComponent.body + ) + tail = bracket_split_build_line( + tail_leaves, line, matching_bracket, component=_BracketSplitComponent.tail + ) + bracket_split_succeeded_or_raise(head, body, tail) + for result in (head, body, tail): + if result: + yield result + + +def right_hand_split( + line: Line, + mode: Mode, + features: Collection[Feature] = (), + omit: Collection[LeafID] = (), +) -> Iterator[Line]: + """Split line into many lines, starting with the last matching bracket pair. + + If the split was by optional parentheses, attempt splitting without them, too. + `omit` is a collection of closing bracket IDs that shouldn't be considered for + this split. + + Note: running this function modifies `bracket_depth` on the leaves of `line`. + """ + rhs_result = _first_right_hand_split(line, omit=omit) + yield from _maybe_split_omitting_optional_parens( + rhs_result, line, mode, features=features, omit=omit + ) + + +def _first_right_hand_split( + line: Line, + omit: Collection[LeafID] = (), +) -> RHSResult: + """Split the line into head, body, tail starting with the last bracket pair. + + Note: this function should not have side effects. It's relied upon by + _maybe_split_omitting_optional_parens to get an opinion whether to prefer + splitting on the right side of an assignment statement. + """ + tail_leaves: list[Leaf] = [] + body_leaves: list[Leaf] = [] + head_leaves: list[Leaf] = [] + current_leaves = tail_leaves + opening_bracket: Leaf | None = None + closing_bracket: Leaf | None = None + for leaf in reversed(line.leaves): + if current_leaves is body_leaves: + if leaf is opening_bracket: + current_leaves = head_leaves if body_leaves else tail_leaves + current_leaves.append(leaf) + if current_leaves is tail_leaves: + if leaf.type in CLOSING_BRACKETS and id(leaf) not in omit: + opening_bracket = leaf.opening_bracket + closing_bracket = leaf + current_leaves = body_leaves + if not (opening_bracket and closing_bracket and head_leaves): + # If there is no opening or closing_bracket that means the split failed and + # all content is in the tail. Otherwise, if `head_leaves` are empty, it means + # the matching `opening_bracket` wasn't available on `line` anymore. + raise CannotSplit("No brackets found") + + tail_leaves.reverse() + body_leaves.reverse() + head_leaves.reverse() + + body: Line | None = None + if ( + Preview.hug_parens_with_braces_and_square_brackets in line.mode + and tail_leaves[0].value + and tail_leaves[0].opening_bracket is head_leaves[-1] + ): + inner_body_leaves = list(body_leaves) + hugged_opening_leaves: list[Leaf] = [] + hugged_closing_leaves: list[Leaf] = [] + is_unpacking = body_leaves[0].type in [token.STAR, token.DOUBLESTAR] + unpacking_offset: int = 1 if is_unpacking else 0 + while ( + len(inner_body_leaves) >= 2 + unpacking_offset + and inner_body_leaves[-1].type in CLOSING_BRACKETS + and inner_body_leaves[-1].opening_bracket + is inner_body_leaves[unpacking_offset] + ): + if unpacking_offset: + hugged_opening_leaves.append(inner_body_leaves.pop(0)) + unpacking_offset = 0 + hugged_opening_leaves.append(inner_body_leaves.pop(0)) + hugged_closing_leaves.insert(0, inner_body_leaves.pop()) + + if hugged_opening_leaves and inner_body_leaves: + inner_body = bracket_split_build_line( + inner_body_leaves, + line, + hugged_opening_leaves[-1], + component=_BracketSplitComponent.body, + ) + if ( + line.mode.magic_trailing_comma + and inner_body_leaves[-1].type == token.COMMA + ): + should_hug = True + else: + line_length = line.mode.line_length - sum( + len(str(leaf)) + for leaf in hugged_opening_leaves + hugged_closing_leaves + ) + if is_line_short_enough( + inner_body, mode=replace(line.mode, line_length=line_length) + ): + # Do not hug if it fits on a single line. + should_hug = False + else: + should_hug = True + if should_hug: + body_leaves = inner_body_leaves + head_leaves.extend(hugged_opening_leaves) + tail_leaves = hugged_closing_leaves + tail_leaves + body = inner_body # No need to re-calculate the body again later. + + head = bracket_split_build_line( + head_leaves, line, opening_bracket, component=_BracketSplitComponent.head + ) + if body is None: + body = bracket_split_build_line( + body_leaves, line, opening_bracket, component=_BracketSplitComponent.body + ) + tail = bracket_split_build_line( + tail_leaves, line, opening_bracket, component=_BracketSplitComponent.tail + ) + bracket_split_succeeded_or_raise(head, body, tail) + return RHSResult(head, body, tail, opening_bracket, closing_bracket) + + +def _maybe_split_omitting_optional_parens( + rhs: RHSResult, + line: Line, + mode: Mode, + features: Collection[Feature] = (), + omit: Collection[LeafID] = (), +) -> Iterator[Line]: + if ( + Feature.FORCE_OPTIONAL_PARENTHESES not in features + # the opening bracket is an optional paren + and rhs.opening_bracket.type == token.LPAR + and not rhs.opening_bracket.value + # the closing bracket is an optional paren + and rhs.closing_bracket.type == token.RPAR + and not rhs.closing_bracket.value + # it's not an import (optional parens are the only thing we can split on + # in this case; attempting a split without them is a waste of time) + and not line.is_import + # and we can actually remove the parens + and can_omit_invisible_parens(rhs, mode.line_length, mode) + ): + omit = {id(rhs.closing_bracket), *omit} + try: + # The RHSResult Omitting Optional Parens. + rhs_oop = _first_right_hand_split(line, omit=omit) + if _prefer_split_rhs_oop_over_rhs(rhs_oop, rhs, mode): + yield from _maybe_split_omitting_optional_parens( + rhs_oop, line, mode, features=features, omit=omit + ) + return + + except CannotSplit as e: + # For chained assignments we want to use the previous successful split + if line.is_chained_assignment: + pass + + elif ( + not can_be_split(rhs.body) + and not is_line_short_enough(rhs.body, mode=mode) + and not ( + Preview.wrap_long_dict_values_in_parens + and rhs.opening_bracket.parent + and rhs.opening_bracket.parent.parent + and rhs.opening_bracket.parent.parent.type == syms.dictsetmaker + ) + and not ( + rhs.opening_bracket.parent + and rhs.opening_bracket.parent.parent + and rhs.opening_bracket.parent.parent.type == syms.case_block + ) + ): + raise CannotSplit( + "Splitting failed, body is still too long and can't be split." + ) from e + + elif ( + rhs.head.contains_multiline_strings() + or rhs.tail.contains_multiline_strings() + ): + raise CannotSplit( + "The current optional pair of parentheses is bound to fail to" + " satisfy the splitting algorithm because the head or the tail" + " contains multiline strings which by definition never fit one" + " line." + ) from e + + ensure_visible(rhs.opening_bracket) + ensure_visible(rhs.closing_bracket) + for result in (rhs.head, rhs.body, rhs.tail): + if result: + yield result + + +def _prefer_split_rhs_oop_over_rhs( + rhs_oop: RHSResult, rhs: RHSResult, mode: Mode +) -> bool: + """ + Returns whether we should prefer the result from a split omitting optional parens + (rhs_oop) over the original (rhs). + """ + # contains unsplittable type ignore + if ( + rhs_oop.head.contains_unsplittable_type_ignore() + or rhs_oop.body.contains_unsplittable_type_ignore() + or rhs_oop.tail.contains_unsplittable_type_ignore() + ): + return True + + # Retain optional parens around dictionary values + if ( + Preview.wrap_long_dict_values_in_parens + and rhs.opening_bracket.parent + and rhs.opening_bracket.parent.parent + and rhs.opening_bracket.parent.parent.type == syms.dictsetmaker + and rhs.body.bracket_tracker.delimiters + ): + # Unless the split is inside the key + return any(leaf.type == token.COLON for leaf in rhs_oop.tail.leaves) + + # the split is right after `=` + if not (len(rhs.head.leaves) >= 2 and rhs.head.leaves[-2].type == token.EQUAL): + return True + + # the left side of assignment contains brackets + if not any(leaf.type in BRACKETS for leaf in rhs.head.leaves[:-1]): + return True + + # the left side of assignment is short enough (the -1 is for the ending optional + # paren) + if not is_line_short_enough( + rhs.head, mode=replace(mode, line_length=mode.line_length - 1) + ): + return True + + # the left side of assignment won't explode further because of magic trailing comma + if rhs.head.magic_trailing_comma is not None: + return True + + # If we have multiple targets, we prefer more `=`s on the head vs pushing them to + # the body + rhs_head_equal_count = [leaf.type for leaf in rhs.head.leaves].count(token.EQUAL) + rhs_oop_head_equal_count = [leaf.type for leaf in rhs_oop.head.leaves].count( + token.EQUAL + ) + if rhs_head_equal_count > 1 and rhs_head_equal_count > rhs_oop_head_equal_count: + return False + + has_closing_bracket_after_assign = False + for leaf in reversed(rhs_oop.head.leaves): + if leaf.type == token.EQUAL: + break + if leaf.type in CLOSING_BRACKETS: + has_closing_bracket_after_assign = True + break + return ( + # contains matching brackets after the `=` (done by checking there is a + # closing bracket) + has_closing_bracket_after_assign + or ( + # the split is actually from inside the optional parens (done by checking + # the first line still contains the `=`) + any(leaf.type == token.EQUAL for leaf in rhs_oop.head.leaves) + # the first line is short enough + and is_line_short_enough(rhs_oop.head, mode=mode) + ) + ) + + +def bracket_split_succeeded_or_raise(head: Line, body: Line, tail: Line) -> None: + """Raise :exc:`CannotSplit` if the last left- or right-hand split failed. + + Do nothing otherwise. + + A left- or right-hand split is based on a pair of brackets. Content before + (and including) the opening bracket is left on one line, content inside the + brackets is put on a separate line, and finally content starting with and + following the closing bracket is put on a separate line. + + Those are called `head`, `body`, and `tail`, respectively. If the split + produced the same line (all content in `head`) or ended up with an empty `body` + and the `tail` is just the closing bracket, then it's considered failed. + """ + tail_len = len(str(tail).strip()) + if not body: + if tail_len == 0: + raise CannotSplit("Splitting brackets produced the same line") + + elif tail_len < 3: + raise CannotSplit( + f"Splitting brackets on an empty body to save {tail_len} characters is" + " not worth it" + ) + + +def _ensure_trailing_comma( + leaves: list[Leaf], original: Line, opening_bracket: Leaf +) -> bool: + if not leaves: + return False + # Ensure a trailing comma for imports + if original.is_import: + return True + # ...and standalone function arguments + if not original.is_def: + return False + if opening_bracket.value != "(": + return False + # Don't add commas if we already have any commas + if any( + leaf.type == token.COMMA and not is_part_of_annotation(leaf) for leaf in leaves + ): + return False + + # Find a leaf with a parent (comments don't have parents) + leaf_with_parent = next((leaf for leaf in leaves if leaf.parent), None) + if leaf_with_parent is None: + return True + # Don't add commas inside parenthesized return annotations + if get_annotation_type(leaf_with_parent) == "return": + return False + # Don't add commas inside PEP 604 unions + if ( + leaf_with_parent.parent + and leaf_with_parent.parent.next_sibling + and leaf_with_parent.parent.next_sibling.type == token.VBAR + ): + return False + return True + + +def bracket_split_build_line( + leaves: list[Leaf], + original: Line, + opening_bracket: Leaf, + *, + component: _BracketSplitComponent, +) -> Line: + """Return a new line with given `leaves` and respective comments from `original`. + + If it's the head component, brackets will be tracked so trailing commas are + respected. + + If it's the body component, the result line is one-indented inside brackets and as + such has its first leaf's prefix normalized and a trailing comma added when + expected. + """ + result = Line(mode=original.mode, depth=original.depth) + if component is _BracketSplitComponent.body: + result.inside_brackets = True + result.depth += 1 + if _ensure_trailing_comma(leaves, original, opening_bracket): + for i in range(len(leaves) - 1, -1, -1): + if leaves[i].type == STANDALONE_COMMENT: + continue + + if leaves[i].type != token.COMMA: + new_comma = Leaf(token.COMMA, ",") + leaves.insert(i + 1, new_comma) + break + + leaves_to_track: set[LeafID] = set() + if component is _BracketSplitComponent.head: + leaves_to_track = get_leaves_inside_matching_brackets(leaves) + # Populate the line + for leaf in leaves: + result.append( + leaf, + preformatted=True, + track_bracket=id(leaf) in leaves_to_track, + ) + for comment_after in original.comments_after(leaf): + result.append(comment_after, preformatted=True) + if component is _BracketSplitComponent.body and should_split_line( + result, opening_bracket + ): + result.should_split_rhs = True + return result + + +def dont_increase_indentation(split_func: Transformer) -> Transformer: + """Normalize prefix of the first leaf in every line returned by `split_func`. + + This is a decorator over relevant split functions. + """ + + @wraps(split_func) + def split_wrapper( + line: Line, features: Collection[Feature], mode: Mode + ) -> Iterator[Line]: + for split_line in split_func(line, features, mode): + split_line.leaves[0].prefix = "" + yield split_line + + return split_wrapper + + +def _get_last_non_comment_leaf(line: Line) -> int | None: + for leaf_idx in range(len(line.leaves) - 1, 0, -1): + if line.leaves[leaf_idx].type != STANDALONE_COMMENT: + return leaf_idx + return None + + +def _can_add_trailing_comma(leaf: Leaf, features: Collection[Feature]) -> bool: + if is_vararg(leaf, within={syms.typedargslist}): + return Feature.TRAILING_COMMA_IN_DEF in features + if is_vararg(leaf, within={syms.arglist, syms.argument}): + return Feature.TRAILING_COMMA_IN_CALL in features + return True + + +def _safe_add_trailing_comma(safe: bool, delimiter_priority: int, line: Line) -> Line: + if ( + safe + and delimiter_priority == COMMA_PRIORITY + and line.leaves[-1].type != token.COMMA + and line.leaves[-1].type != STANDALONE_COMMENT + ): + new_comma = Leaf(token.COMMA, ",") + line.append(new_comma) + return line + + +MIGRATE_COMMENT_DELIMITERS = {STRING_PRIORITY, COMMA_PRIORITY} + + +def _can_defer_lone_comparator_to_rhs(line: Line, mode: Mode) -> bool: + """Return True if the lone comparator on `line` can defer to right_hand_split. + + Caller has already established exactly one delimiter at + `COMPARATOR_PRIORITY`. We defer only when: + + - the LHS up to the comparator has no opening brackets, so the existing + "break before the comparator" wouldn't produce a balanced two-sided + split anyway, and + - `right_hand_split` would produce a head that fits in the line length, + so we don't strand `if t` on its own line just to push it back onto an + overflowing single line when the RHS bracket can't be exploded + usefully (e.g. an empty `decode()` paren). + """ + past_comparator = False + for leaf in line.leaves: + if leaf.type in OPENING_BRACKETS and not past_comparator: + return False + if not past_comparator and ( + line.bracket_tracker.delimiters.get(id(leaf)) == COMPARATOR_PRIORITY + ): + past_comparator = True + try: + rhs = _first_right_hand_split(line) + except CannotSplit: + return False + return is_line_short_enough(rhs.head, mode=mode) + + +@dont_increase_indentation +def delimiter_split( + line: Line, features: Collection[Feature], mode: Mode +) -> Iterator[Line]: + """Split according to delimiters of the highest priority. + + If the appropriate Features are given, the split will add trailing commas + also in function signatures and calls that contain `*` and `**`. + """ + if len(line.leaves) == 0: + raise CannotSplit("Line empty") from None + last_leaf = line.leaves[-1] + + bt = line.bracket_tracker + try: + delimiter_priority = bt.max_delimiter_priority(exclude={id(last_leaf)}) + except ValueError: + raise CannotSplit("No delimiters found") from None + + if ( + delimiter_priority == DOT_PRIORITY + and bt.delimiter_count_with_priority(delimiter_priority) == 1 + ): + raise CannotSplit("Splitting a single attribute from its owner looks wrong") + + if ( + Preview.hug_comparator in mode + and delimiter_priority == COMPARATOR_PRIORITY + and bt.delimiter_count_with_priority(delimiter_priority) == 1 + and _can_defer_lone_comparator_to_rhs(line, mode) + ): + raise CannotSplit("Bracketed RHS will explode via right_hand_split") + + current_line = Line( + mode=line.mode, depth=line.depth, inside_brackets=line.inside_brackets + ) + lowest_depth = sys.maxsize + trailing_comma_safe = True + + def append_to_line(leaf: Leaf) -> Iterator[Line]: + """Append `leaf` to current line or to new line if appending impossible.""" + nonlocal current_line + try: + current_line.append_safe(leaf, preformatted=True) + except ValueError: + yield current_line + + current_line = Line( + mode=line.mode, depth=line.depth, inside_brackets=line.inside_brackets + ) + current_line.append(leaf) + + def append_comments(leaf: Leaf) -> Iterator[Line]: + for comment_after in line.comments_after(leaf): + yield from append_to_line(comment_after) + + last_non_comment_leaf = _get_last_non_comment_leaf(line) + for leaf_idx, leaf in enumerate(line.leaves): + yield from append_to_line(leaf) + + previous_priority = leaf_idx > 0 and bt.delimiters.get( + id(line.leaves[leaf_idx - 1]) + ) + if ( + previous_priority != delimiter_priority + or delimiter_priority in MIGRATE_COMMENT_DELIMITERS + ): + yield from append_comments(leaf) + + lowest_depth = min(lowest_depth, leaf.bracket_depth) + if trailing_comma_safe and leaf.bracket_depth == lowest_depth: + trailing_comma_safe = _can_add_trailing_comma(leaf, features) + + if last_leaf.type == STANDALONE_COMMENT and leaf_idx == last_non_comment_leaf: + current_line = _safe_add_trailing_comma( + trailing_comma_safe, delimiter_priority, current_line + ) + + leaf_priority = bt.delimiters.get(id(leaf)) + if leaf_priority == delimiter_priority: + if ( + leaf_idx + 1 < len(line.leaves) + and delimiter_priority not in MIGRATE_COMMENT_DELIMITERS + ): + yield from append_comments(line.leaves[leaf_idx + 1]) + + yield current_line + current_line = Line( + mode=line.mode, depth=line.depth, inside_brackets=line.inside_brackets + ) + + if current_line: + current_line = _safe_add_trailing_comma( + trailing_comma_safe, delimiter_priority, current_line + ) + yield current_line + + +@dont_increase_indentation +def standalone_comment_split( + line: Line, features: Collection[Feature], mode: Mode +) -> Iterator[Line]: + """Split standalone comments from the rest of the line.""" + if not line.contains_standalone_comments(): + raise CannotSplit("Line does not have any standalone comments") + + current_line = Line( + mode=line.mode, depth=line.depth, inside_brackets=line.inside_brackets + ) + + def append_to_line(leaf: Leaf) -> Iterator[Line]: + """Append `leaf` to current line or to new line if appending impossible.""" + nonlocal current_line + try: + current_line.append_safe(leaf, preformatted=True) + except ValueError: + yield current_line + + current_line = Line( + line.mode, depth=line.depth, inside_brackets=line.inside_brackets + ) + current_line.append(leaf) + + for leaf in line.leaves: + yield from append_to_line(leaf) + + for comment_after in line.comments_after(leaf): + yield from append_to_line(comment_after) + + if current_line: + yield current_line + + +def _force_standalone_comment_split(line: Line) -> Iterator[Line]: + """Last-resort split at every standalone-comment boundary.""" + current_line = Line( + mode=line.mode, depth=line.depth, inside_brackets=line.inside_brackets + ) + for leaf in line.leaves: + if current_line.leaves and ( + leaf.type == STANDALONE_COMMENT or current_line.is_comment + ): + yield current_line + current_line = Line( + mode=line.mode, depth=line.depth, inside_brackets=line.inside_brackets + ) + current_line.append(leaf, preformatted=True) + if current_line: + yield current_line + + +def normalize_invisible_parens( + node: Node, parens_after: set[str], *, mode: Mode, features: Collection[Feature] +) -> None: + """Make existing optional parentheses invisible or create new ones. + + `parens_after` is a set of string leaf values immediately after which parens + should be put. + + Standardizes on visible parentheses for single-element tuples, and keeps + existing visible parentheses for other tuples and generator expressions. + """ + for pc in list_comments(node.prefix, is_endmarker=False, mode=mode): + if contains_fmt_directive(pc.value, FMT_OFF): + # This `node` has a prefix with `# fmt: off`, don't mess with parens. + return + + # The multiple context managers grammar has a different pattern, thus this is + # separate from the for-loop below. This possibly wraps them in invisible parens, + # and later will be removed in remove_with_parens when needed. + if node.type == syms.with_stmt: + _maybe_wrap_cms_in_parens(node, mode, features) + + check_lpar = False + for index, child in enumerate(list(node.children)): + # Fixes a bug where invisible parens are not properly stripped from + # assignment statements that contain type annotations. + if isinstance(child, Node) and child.type == syms.annassign: + normalize_invisible_parens( + child, parens_after=parens_after, mode=mode, features=features + ) + + # Fixes a bug where invisible parens are not properly wrapped around + # case blocks. + if isinstance(child, Node) and child.type == syms.case_block: + normalize_invisible_parens( + child, parens_after={"case"}, mode=mode, features=features + ) + + # Add parentheses around if guards in case blocks + if isinstance(child, Node) and child.type == syms.guard: + normalize_invisible_parens( + child, parens_after={"if"}, mode=mode, features=features + ) + + # Add parentheses around long tuple unpacking in assignments. + if ( + index == 0 + and isinstance(child, Node) + and child.type == syms.testlist_star_expr + ): + check_lpar = True + + if ( + index == 0 + and isinstance(child, Node) + and child.type == syms.atom + and node.type == syms.expr_stmt + and not _atom_has_magic_trailing_comma(child, mode) + and not _is_atom_multiline(child) + ): + if maybe_make_parens_invisible_in_atom( + child, + parent=node, + mode=mode, + features=features, + remove_brackets_around_comma=True, + allow_star_expr=True, + ): + wrap_in_parentheses(node, child, visible=False) + + if check_lpar: + if ( + child.type == syms.atom + and node.type == syms.for_stmt + and isinstance(child.prev_sibling, Leaf) + and child.prev_sibling.type == token.NAME + and child.prev_sibling.value == "for" + ): + if maybe_make_parens_invisible_in_atom( + child, + parent=node, + mode=mode, + features=features, + remove_brackets_around_comma=True, + ): + wrap_in_parentheses(node, child, visible=False) + elif isinstance(child, Node) and node.type == syms.with_stmt: + remove_with_parens(child, node, mode=mode, features=features) + elif ( + isinstance(child, Node) + and node.type == syms.yield_expr + and child.type == syms.yield_arg + and Preview.parenthesize_tuple_in_yield in mode + ): + if ( + len(child.children) == 1 + and child.children[0].type != syms.atom + and is_one_tuple(child.children[0]) + ): + wrap_in_parentheses(node, child, visible=True) + elif child.type == syms.atom and not ( + "in" in parens_after + and len(child.children) == 3 + and is_lpar_token(child.children[0]) + and is_rpar_token(child.children[-1]) + and child.children[1].type in {syms.test, syms.lambdef} + ): + if maybe_make_parens_invisible_in_atom( + child, parent=node, mode=mode, features=features + ): + wrap_in_parentheses(node, child, visible=False) + elif is_one_tuple(child): + wrap_in_parentheses(node, child, visible=True) + elif node.type == syms.import_from: + _normalize_import_from(node, child, index) + break + elif ( + index == 1 + and child.type == token.STAR + and node.type == syms.except_clause + ): + # In except* (PEP 654), the star is actually part of + # of the keyword. So we need to skip the insertion of + # invisible parentheses to work more precisely. + continue + + elif ( + isinstance(child, Leaf) + and child.next_sibling is not None + and child.next_sibling.type == token.COLON + and child.value == "case" + ): + # A special patch for "case case:" scenario, the second occurrence + # of case will be not parsed as a Python keyword. + break + + elif isinstance(child, Node) and child.type == syms.guard: + # Guard nodes handle their own inner wrapping. Wrapping the guard + # itself can produce invalid output when the case pattern splits. + pass + + elif not is_multiline_string(child): + if ( + Preview.fix_if_guard_explosion_in_case_statement in mode + and node.type == syms.guard + ): + mock_line = Line(mode=mode) + for leaf in child.leaves(): + mock_line.append(leaf) + # If it's a guard AND it's short, we DON'T wrap + if not is_line_short_enough(mock_line, mode=mode): + wrap_in_parentheses(node, child, visible=False) + else: + wrap_in_parentheses(node, child, visible=False) + + comma_check = child.type == token.COMMA + + check_lpar = isinstance(child, Leaf) and ( + child.value in parens_after or comma_check + ) + + +def _normalize_import_from(parent: Node, child: LN, index: int) -> None: + # "import from" nodes store parentheses directly as part of + # the statement + if is_lpar_token(child): + assert is_rpar_token(parent.children[-1]) + # make parentheses invisible + child.value = "" + parent.children[-1].value = "" + elif child.type != token.STAR: + # insert invisible parentheses + parent.insert_child(index, Leaf(token.LPAR, "")) + parent.append_child(Leaf(token.RPAR, "")) + + +def remove_await_parens(node: Node, mode: Mode, features: Collection[Feature]) -> None: + if node.children[0].type == token.AWAIT and len(node.children) > 1: + if ( + node.children[1].type == syms.atom + and node.children[1].children[0].type == token.LPAR + ): + if maybe_make_parens_invisible_in_atom( + node.children[1], + parent=node, + mode=mode, + features=features, + remove_brackets_around_comma=True, + ): + wrap_in_parentheses(node, node.children[1], visible=False) + + # Since await is an expression we shouldn't remove + # brackets in cases where this would change + # the AST due to operator precedence. + # Therefore we only aim to remove brackets around + # power nodes that aren't also await expressions themselves. + # https://peps.python.org/pep-0492/#updated-operator-precedence-table + # N.B. We've still removed any redundant nested brackets though :) + opening_bracket = cast(Leaf, node.children[1].children[0]) + closing_bracket = cast(Leaf, node.children[1].children[-1]) + bracket_contents = node.children[1].children[1] + if isinstance(bracket_contents, Node) and ( + bracket_contents.type != syms.power + or bracket_contents.children[0].type == token.AWAIT + or any( + isinstance(child, Leaf) and child.type == token.DOUBLESTAR + for child in bracket_contents.children + ) + ): + ensure_visible(opening_bracket) + ensure_visible(closing_bracket) + + +def _maybe_wrap_cms_in_parens( + node: Node, mode: Mode, features: Collection[Feature] +) -> None: + """When enabled and safe, wrap the multiple context managers in invisible parens. + + It is only safe when `features` contain Feature.PARENTHESIZED_CONTEXT_MANAGERS. + """ + if ( + Feature.PARENTHESIZED_CONTEXT_MANAGERS not in features + or len(node.children) <= 2 + # If it's an atom, it's already wrapped in parens. + or node.children[1].type == syms.atom + ): + return + colon_index: int | None = None + for i in range(2, len(node.children)): + if node.children[i].type == token.COLON: + colon_index = i + break + if colon_index is not None: + lpar = Leaf(token.LPAR, "") + rpar = Leaf(token.RPAR, "") + context_managers = node.children[1:colon_index] + for child in context_managers: + child.remove() + # After wrapping, the with_stmt will look like this: + # with_stmt + # NAME 'with' + # atom + # LPAR '' + # testlist_gexp + # ... <-- context_managers + # /testlist_gexp + # RPAR '' + # /atom + # COLON ':' + new_child = Node( + syms.atom, [lpar, Node(syms.testlist_gexp, context_managers), rpar] + ) + node.insert_child(1, new_child) + + +def remove_with_parens( + node: Node, parent: Node, mode: Mode, features: Collection[Feature] +) -> None: + """Recursively hide optional parens in `with` statements.""" + # Removing all unnecessary parentheses in with statements in one pass is a tad + # complex as different variations of bracketed statements result in pretty + # different parse trees: + # + # with (open("file")) as f: # this is an asexpr_test + # ... + # + # with (open("file") as f): # this is an atom containing an + # ... # asexpr_test + # + # with (open("file")) as f, (open("file")) as f: # this is asexpr_test, COMMA, + # ... # asexpr_test + # + # with (open("file") as f, open("file") as f): # an atom containing a + # ... # testlist_gexp which then + # # contains multiple asexpr_test(s) + if node.type == syms.atom: + if maybe_make_parens_invisible_in_atom( + node, + parent=parent, + mode=mode, + features=features, + remove_brackets_around_comma=True, + ): + wrap_in_parentheses(parent, node, visible=False) + if isinstance(node.children[1], Node): + remove_with_parens(node.children[1], node, mode=mode, features=features) + elif node.type == syms.testlist_gexp: + for child in node.children: + if isinstance(child, Node): + remove_with_parens(child, node, mode=mode, features=features) + elif node.type == syms.asexpr_test and not any( + leaf.type == token.COLONEQUAL for leaf in node.leaves() + ): + if maybe_make_parens_invisible_in_atom( + node.children[0], + parent=node, + mode=mode, + features=features, + remove_brackets_around_comma=True, + ): + wrap_in_parentheses(node, node.children[0], visible=False) + + +def _atom_has_magic_trailing_comma(node: LN, mode: Mode) -> bool: + """Check if an atom node has a magic trailing comma. + + Returns True for single-element tuples with trailing commas like (a,), + which should be preserved to maintain their tuple type. + """ + if not mode.magic_trailing_comma: + return False + + return is_one_tuple(node) + + +def _is_atom_multiline(node: LN) -> bool: + """Check if an atom node is multiline (indicating intentional formatting).""" + if not isinstance(node, Node) or len(node.children) < 3: + return False + + # Check the middle child (between LPAR and RPAR) for newlines in its subtree + # The first child's prefix contains blank lines/comments before the opening paren + middle = node.children[1] + for child in middle.pre_order(): + if isinstance(child, Leaf) and "\n" in child.prefix: + return True + + return False + + +def maybe_make_parens_invisible_in_atom( + node: LN, + parent: LN, + mode: Mode, + features: Collection[Feature], + remove_brackets_around_comma: bool = False, + allow_star_expr: bool = False, +) -> bool: + """If it's safe, make the parens in the atom `node` invisible, recursively. + Additionally, remove repeated, adjacent invisible parens from the atom `node` + as they are redundant. + + Returns whether the node should itself be wrapped in invisible parentheses. + """ + if ( + node.type not in (syms.atom, syms.expr) + or is_empty_tuple(node) + or is_one_tuple(node) + or (is_tuple(node) and parent.type == syms.asexpr_test) + or ( + is_tuple(node) + and parent.type == syms.with_stmt + and has_sibling_with_type(node, token.COMMA) + ) + or (is_yield(node) and parent.type != syms.expr_stmt) + or ( + # This condition tries to prevent removing non-optional brackets + # around a tuple, however, can be a bit overzealous so we provide + # and option to skip this check for `for` and `with` statements. + not remove_brackets_around_comma + and max_delimiter_priority_in_atom(node) >= COMMA_PRIORITY + # Remove parentheses around multiple exception types in except and + # except* without as. See PEP 758 for details. + and not ( + Feature.UNPARENTHESIZED_EXCEPT_TYPES in features + # is a tuple + and is_tuple(node) + # has a parent node + and node.parent is not None + # parent is an except clause + and node.parent.type == syms.except_clause + # is not immediately followed by as clause + and not ( + node.next_sibling is not None + and is_name_token(node.next_sibling) + and node.next_sibling.value == "as" + ) + ) + ) + or is_tuple_containing_walrus(node) + or (not allow_star_expr and is_tuple_containing_star(node)) + or is_generator(node) + ): + return False + + if is_walrus_assignment(node): + if parent.type in [ + syms.annassign, + syms.expr_stmt, + syms.assert_stmt, + syms.return_stmt, + syms.yield_arg, + syms.yield_expr, + syms.except_clause, + syms.funcdef, + syms.with_stmt, + syms.testlist_gexp, + syms.tname, + # these ones aren't useful to end users, but they do please fuzzers + syms.for_stmt, + syms.del_stmt, + syms.for_stmt, + ]: + return False + + first = node.children[0] + last = node.children[-1] + if is_lpar_token(first) and is_rpar_token(last): + middle = node.children[1] + # make parentheses invisible + if ( + # If the prefix of `middle` includes a type comment with + # ignore annotation, then we do not remove the parentheses + not is_type_ignore_comment_string(middle.prefix.strip(), mode=mode) + ): + first.value = "" + last.value = "" + maybe_make_parens_invisible_in_atom( + middle, + parent=parent, + mode=mode, + features=features, + remove_brackets_around_comma=remove_brackets_around_comma, + ) + + if is_atom_with_invisible_parens(middle): + # Strip the invisible parens from `middle` by replacing + # it with the child in-between the invisible parens + middle.replace(middle.children[1]) + + if middle.children[0].prefix.strip(): + # Preserve comments before first paren + middle.children[1].prefix = ( + middle.children[0].prefix + middle.children[1].prefix + ) + + if middle.children[-1].prefix.strip(): + # Preserve comments before last paren + last.prefix = middle.children[-1].prefix + last.prefix + + return False + + return True + + +def should_split_line(line: Line, opening_bracket: Leaf) -> bool: + """Should `line` be immediately split with `delimiter_split()` after RHS?""" + + if not (opening_bracket.parent and opening_bracket.value in "[{("): + return False + + # We're essentially checking if the body is delimited by commas and there's more + # than one of them (we're excluding the trailing comma and if the delimiter priority + # is still commas, that means there's more). + exclude = set() + trailing_comma = False + try: + last_leaf = line.leaves[-1] + if last_leaf.type == token.COMMA: + trailing_comma = True + exclude.add(id(last_leaf)) + max_priority = line.bracket_tracker.max_delimiter_priority(exclude=exclude) + except (IndexError, ValueError): + return False + + return max_priority == COMMA_PRIORITY and ( + (line.mode.magic_trailing_comma and trailing_comma) + # always explode imports + or opening_bracket.parent.type in {syms.atom, syms.import_from} + ) + + +def generate_trailers_to_omit(line: Line, line_length: int) -> Iterator[set[LeafID]]: + """Generate sets of closing bracket IDs that should be omitted in a RHS. + + Brackets can be omitted if the entire trailer up to and including + a preceding closing bracket fits in one line. + + Yielded sets are cumulative (contain results of previous yields, too). First + set is empty, unless the line should explode, in which case bracket pairs until + the one that needs to explode are omitted. + """ + + omit: set[LeafID] = set() + if not line.magic_trailing_comma: + yield omit + + length = 4 * line.depth + opening_bracket: Leaf | None = None + closing_bracket: Leaf | None = None + inner_brackets: set[LeafID] = set() + for index, leaf, leaf_length in line.enumerate_with_length(is_reversed=True): + length += leaf_length + if length > line_length: + break + + has_inline_comment = leaf_length > len(leaf.value) + len(leaf.prefix) + if leaf.type == STANDALONE_COMMENT or has_inline_comment: + break + + if opening_bracket: + if leaf is opening_bracket: + opening_bracket = None + elif leaf.type in CLOSING_BRACKETS: + prev = line.leaves[index - 1] if index > 0 else None + if ( + prev + and prev.type == token.COMMA + and leaf.opening_bracket is not None + and not is_one_sequence_between( + leaf.opening_bracket, leaf, line.leaves + ) + ): + # Never omit bracket pairs with trailing commas. + # We need to explode on those. + break + + inner_brackets.add(id(leaf)) + elif leaf.type in CLOSING_BRACKETS: + prev = line.leaves[index - 1] if index > 0 else None + if prev and prev.type in OPENING_BRACKETS: + # Empty brackets would fail a split so treat them as "inner" + # brackets (e.g. only add them to the `omit` set if another + # pair of brackets was good enough. + inner_brackets.add(id(leaf)) + continue + + if closing_bracket: + omit.add(id(closing_bracket)) + omit.update(inner_brackets) + inner_brackets.clear() + yield omit + + if ( + prev + and prev.type == token.COMMA + and leaf.opening_bracket is not None + and not is_one_sequence_between(leaf.opening_bracket, leaf, line.leaves) + ): + # Never omit bracket pairs with trailing commas. + # We need to explode on those. + break + + if leaf.value: + opening_bracket = leaf.opening_bracket + closing_bracket = leaf + + +def _over_length_only_due_to_subscript_comment(line: Line, mode: Mode) -> bool: + """Return True if `line` only exceeds `mode.line_length` because of an inline + comment attached to a subscript opening bracket (`[`). + + This is the shape produced by the original of the issue #4733 reproducer: + a comment inside the annotation's subscript brackets renders at the end of + the head line after Black splits the statement, pushing it past the limit. + Taking the FORCE_OPTIONAL_PARENTHESES "second opinion" in that case wraps + the annotation in extra parens and migrates the comment outside the + subscript, which then oscillates on the next formatter pass. + """ + if not line.leaves: + return False + # The over-length must be caused entirely by a trailing comment. + indent = " " * line.depth + leaves_iter = iter(line.leaves) + first = next(leaves_iter) + text_without_comments = f"{first.prefix}{indent}{first.value}" + text_without_comments += "".join(str(leaf) for leaf in leaves_iter) + if str_width(text_without_comments) > mode.line_length: + return False + # And the comment must be attached to a subscript opening bracket. + for leaf_id, comments in line.comments.items(): + if not comments: + continue + leaf = next((lf for lf in line.leaves if id(lf) == leaf_id), None) + if leaf is None or leaf.type != token.LSQB: + return False + return True + + +def run_transformer( + line: Line, + transform: Transformer, + mode: Mode, + features: Collection[Feature], + *, + line_str: str = "", +) -> list[Line]: + if not line_str: + line_str = line_to_string(line) + result: list[Line] = [] + for transformed_line in transform(line, features, mode): + if str(transformed_line).strip("\n") == line_str: + raise CannotTransform("Line transformer returned an unchanged result") + + result.extend(transform_line(transformed_line, mode=mode, features=features)) + + features_set = set(features) + if ( + Feature.FORCE_OPTIONAL_PARENTHESES in features_set + or transform.__class__.__name__ != "rhs" + or not line.bracket_tracker.invisible + or any(bracket.value for bracket in line.bracket_tracker.invisible) + or line.contains_multiline_strings() + or result[0].contains_uncollapsable_type_comments() + or result[0].contains_unsplittable_type_ignore() + or is_line_short_enough(result[0], mode=mode) + # result[0] only exceeds the length because of a comment attached to a + # subscript opening bracket. Taking the FORCE_OPTIONAL_PARENTHESES + # "second opinion" wraps the annotation in extra invisible parens and + # migrates the comment outside the subscript, which then oscillates with + # a deeper-bracket split on the next formatter pass (issue #4733). + or _over_length_only_due_to_subscript_comment(result[0], mode) + # If any leaves have no parents (which _can_ occur since + # `transform(line)` potentially destroys the line's underlying node + # structure), then we can't proceed. Doing so would cause the below + # call to `append_leaves()` to fail. + or any(leaf.parent is None for leaf in line.leaves) + ): + return result + + line_copy = line.clone() + append_leaves(line_copy, line, line.leaves) + features_fop = features_set | {Feature.FORCE_OPTIONAL_PARENTHESES} + second_opinion = run_transformer( + line_copy, transform, mode, features_fop, line_str=line_str + ) + if all(is_line_short_enough(ln, mode=mode) for ln in second_opinion): + result = second_opinion + return result diff --git a/src/black/lines.py b/src/black/lines.py new file mode 100644 index 0000000..e04f5b1 --- /dev/null +++ b/src/black/lines.py @@ -0,0 +1,1689 @@ +import itertools +import math +from collections.abc import Callable, Iterator, Sequence +from dataclasses import dataclass, field +from typing import NamedTuple, Optional, TypeVar, Union, cast + +from black.brackets import COMMA_PRIORITY, DOT_PRIORITY, BracketTracker +from black.mode import Mode, Preview +from black.nodes import ( + BRACKETS, + CLOSING_BRACKETS, + OPENING_BRACKETS, + STANDALONE_COMMENT, + TEST_DESCENDANTS, + child_towards, + first_leaf, + is_docstring, + is_import, + is_multiline_string, + is_one_sequence_between, + is_type_comment, + is_type_ignore_comment, + is_with_or_async_with_stmt, + last_leaf, + make_simple_prefix, + replace_child, + syms, + whitespace, +) +from black.strings import str_width +from blib2to3.pgen2 import token +from blib2to3.pytree import Leaf, Node + +# types +T = TypeVar("T") +Index = int +LeafID = int +LN = Union[Leaf, Node] + + +@dataclass +class Line: + """Holds leaves and comments. Can be printed with `str(line)`.""" + + mode: Mode = field(repr=False) + depth: int = 0 + leaves: list[Leaf] = field(default_factory=list) + # keys ordered like `leaves` + comments: dict[LeafID, list[Leaf]] = field(default_factory=dict) + bracket_tracker: BracketTracker = field(default_factory=BracketTracker) + inside_brackets: bool = False + should_split_rhs: bool = False + magic_trailing_comma: Leaf | None = None + + def append( + self, leaf: Leaf, preformatted: bool = False, track_bracket: bool = False + ) -> None: + """Add a new `leaf` to the end of the line. + + Unless `preformatted` is True, the `leaf` will receive a new consistent + whitespace prefix and metadata applied by :class:`BracketTracker`. + Trailing commas are maybe removed, unpacked for loop variables are + demoted from being delimiters. + + Inline comments are put aside. + """ + has_value = ( + leaf.type in BRACKETS + # empty fstring and tstring middles must not be truncated + or leaf.type in (token.FSTRING_MIDDLE, token.TSTRING_MIDDLE) + or bool(leaf.value.strip()) + ) + if not has_value: + return + + if leaf.type == token.COLON and self.is_class_paren_empty: + del self.leaves[-2:] + if self.leaves and not preformatted: + # Note: at this point leaf.prefix should be empty except for + # imports, for which we only preserve newlines. + leaf.prefix += whitespace( + leaf, + complex_subscript=self.is_complex_subscript(leaf), + mode=self.mode, + ) + if self.inside_brackets or not preformatted or track_bracket: + self.bracket_tracker.mark(leaf) + if self.mode.magic_trailing_comma: + if self.has_magic_trailing_comma(leaf): + self.magic_trailing_comma = leaf + elif self.has_magic_trailing_comma(leaf): + self.remove_trailing_comma() + if not self.append_comment(leaf): + self.leaves.append(leaf) + + def append_safe(self, leaf: Leaf, preformatted: bool = False) -> None: + """Like :func:`append()` but disallow invalid standalone comment structure. + + Raises ValueError when any `leaf` is appended after a standalone comment + or when a standalone comment is not the first leaf on the line. + """ + if ( + self.bracket_tracker.depth == 0 + or self.bracket_tracker.any_open_for_or_lambda() + ): + if self.is_comment: + raise ValueError("cannot append to standalone comments") + + if self.leaves and leaf.type == STANDALONE_COMMENT: + raise ValueError( + "cannot append standalone comments to a populated line" + ) + + self.append(leaf, preformatted=preformatted) + + @property + def is_comment(self) -> bool: + """Is this line a standalone comment?""" + return len(self.leaves) == 1 and self.leaves[0].type == STANDALONE_COMMENT + + @property + def is_decorator(self) -> bool: + """Is this line a decorator?""" + return bool(self) and self.leaves[0].type == token.AT + + @property + def is_import(self) -> bool: + """Is this an import line?""" + return bool(self) and is_import(self.leaves[0]) + + @property + def is_with_or_async_with_stmt(self) -> bool: + """Is this a with_stmt line?""" + return bool(self) and is_with_or_async_with_stmt(self.leaves[0]) + + @property + def is_class(self) -> bool: + """Is this line a class definition?""" + return ( + bool(self) + and self.leaves[0].type == token.NAME + and self.leaves[0].value == "class" + ) + + @property + def is_stub_class(self) -> bool: + """Is this line a class definition with a body consisting only of "..."?""" + return self.is_class and self.leaves[-3:] == [ + Leaf(token.DOT, ".") for _ in range(3) + ] + + @property + def is_def(self) -> bool: + """Is this a function definition? (Also returns True for async defs.)""" + try: + first_leaf = self.leaves[0] + except IndexError: + return False + + try: + second_leaf: Leaf | None = self.leaves[1] + except IndexError: + second_leaf = None + return (first_leaf.type == token.NAME and first_leaf.value == "def") or ( + first_leaf.type == token.ASYNC + and second_leaf is not None + and second_leaf.type == token.NAME + and second_leaf.value == "def" + ) + + @property + def is_stub_def(self) -> bool: + """Is this line a function definition with a body consisting only of "..."?""" + return self.is_def and self.leaves[-4:] == [Leaf(token.COLON, ":")] + [ + Leaf(token.DOT, ".") for _ in range(3) + ] + + @property + def is_class_paren_empty(self) -> bool: + """Is this a class with no base classes but using parentheses? + + Those are unnecessary and should be removed. + """ + return ( + bool(self) + and len(self.leaves) == 4 + and self.is_class + and self.leaves[2].type == token.LPAR + and self.leaves[2].value == "(" + and self.leaves[3].type == token.RPAR + and self.leaves[3].value == ")" + ) + + @property + def _is_triple_quoted_string(self) -> bool: + """Is the line a triple quoted string?""" + if not self or self.leaves[0].type != token.STRING: + return False + value = self.leaves[0].value + if value.startswith(('"""', "'''")): + return True + if value.startswith(("r'''", 'r"""', "R'''", 'R"""')): + return True + return False + + @property + def is_docstring(self) -> bool: + """Is the line a docstring?""" + return bool(self) and is_docstring(self.leaves[0]) + + @property + def is_chained_assignment(self) -> bool: + """Is the line a chained assignment""" + return [leaf.type for leaf in self.leaves].count(token.EQUAL) > 1 + + @property + def opens_block(self) -> bool: + """Does this line open a new level of indentation.""" + if len(self.leaves) == 0: + return False + return self.leaves[-1].type == token.COLON + + def is_fmt_pass_converted( + self, *, first_leaf_matches: Callable[[Leaf], bool] | None = None + ) -> bool: + """Is this line converted from fmt off/skip code? + + If first_leaf_matches is not None, it only returns True if the first + leaf of converted code matches. + """ + if len(self.leaves) != 1: + return False + leaf = self.leaves[0] + if ( + leaf.type != STANDALONE_COMMENT + or leaf.fmt_pass_converted_first_leaf is None + ): + return False + return first_leaf_matches is None or first_leaf_matches( + leaf.fmt_pass_converted_first_leaf + ) + + def contains_standalone_comments(self) -> bool: + """If so, needs to be split before emitting.""" + for leaf in self.leaves: + if leaf.type == STANDALONE_COMMENT: + return True + + return False + + def contains_implicit_multiline_string_with_comments(self) -> bool: + """Check if we have an implicit multiline string with comments on the line""" + for leaf_type, leaf_group_iterator in itertools.groupby( + self.leaves, lambda leaf: leaf.type + ): + if leaf_type != token.STRING: + continue + leaf_list = list(leaf_group_iterator) + if len(leaf_list) == 1: + continue + for leaf in leaf_list: + if self.comments_after(leaf): + return True + return False + + def contains_uncollapsable_type_comments(self) -> bool: + ignored_ids = set() + try: + last_leaf = self.leaves[-1] + ignored_ids.add(id(last_leaf)) + if last_leaf.type == token.COMMA or ( + last_leaf.type == token.RPAR and not last_leaf.value + ): + # When trailing commas or optional parens are inserted by Black for + # consistency, comments after the previous last element are not moved + # (they don't have to, rendering will still be correct). So we ignore + # trailing commas and invisible. + last_leaf = self.leaves[-2] + ignored_ids.add(id(last_leaf)) + except IndexError: + return False + + # A type comment is uncollapsable if it is attached to a leaf + # that isn't at the end of the line (since that could cause it + # to get associated to a different argument) or if there are + # comments before it (since that could cause it to get hidden + # behind a comment. + comment_seen = False + for leaf_id, comments in self.comments.items(): + for comment in comments: + if is_type_comment(comment, mode=self.mode): + if comment_seen or ( + not is_type_ignore_comment(comment, mode=self.mode) + and leaf_id not in ignored_ids + ): + return True + + comment_seen = True + + return False + + def contains_unsplittable_type_ignore(self) -> bool: + if not self.leaves: + return False + + # If a 'type: ignore' is attached to the end of a line, we + # can't split the line, because we can't know which of the + # subexpressions the ignore was meant to apply to. + # + # We only want this to apply to actual physical lines from the + # original source, though: we don't want the presence of a + # 'type: ignore' at the end of a multiline expression to + # justify pushing it all onto one line. Thus we + # (unfortunately) need to check the actual source lines and + # only report an unsplittable 'type: ignore' if this line was + # one line in the original code. + + # Grab the first and last line numbers, skipping generated leaves + first_line = next((leaf.lineno for leaf in self.leaves if leaf.lineno != 0), 0) + last_line = next( + (leaf.lineno for leaf in reversed(self.leaves) if leaf.lineno != 0), 0 + ) + + if first_line == last_line: + # We look at the last two leaves since a comma or an + # invisible paren could have been added at the end of the + # line. + for node in self.leaves[-2:]: + for comment in self.comments.get(id(node), []): + if is_type_ignore_comment(comment, mode=self.mode): + return True + + return False + + def contains_multiline_strings(self) -> bool: + return any(is_multiline_string(leaf) for leaf in self.leaves) + + def has_magic_trailing_comma(self, closing: Leaf) -> bool: + """Return True if we have a magic trailing comma, that is when: + - there's a trailing comma here + - it's not from single-element square bracket indexing + - it's not a one-tuple + """ + if not ( + closing.type in CLOSING_BRACKETS + and self.leaves + and self.leaves[-1].type == token.COMMA + ): + return False + + if closing.type == token.RBRACE: + return True + + if closing.type == token.RSQB: + if ( + closing.parent is not None + and closing.parent.type == syms.trailer + and closing.opening_bracket is not None + and is_one_sequence_between( + closing.opening_bracket, + closing, + self.leaves, + brackets=(token.LSQB, token.RSQB), + ) + ): + assert closing.prev_sibling is not None + assert closing.prev_sibling.type == syms.subscriptlist + return False + + return True + + if self.is_import: + return True + + if closing.opening_bracket is not None and not is_one_sequence_between( + closing.opening_bracket, closing, self.leaves + ): + return True + + return False + + def append_comment(self, comment: Leaf) -> bool: + """Add an inline or standalone comment to the line.""" + if ( + comment.type == STANDALONE_COMMENT + and self.bracket_tracker.any_open_brackets() + ): + comment.prefix = "" + return False + + if comment.type != token.COMMENT: + return False + + if not self.leaves: + comment.type = STANDALONE_COMMENT + comment.prefix = "" + return False + + last_leaf = self.leaves[-1] + if ( + last_leaf.type == token.RPAR + and not last_leaf.value + and last_leaf.parent + and len(list(last_leaf.parent.leaves())) <= 3 + and not is_type_comment(comment, mode=self.mode) + ): + # Comments on an optional parens wrapping a single leaf should belong to + # the wrapped node except if it's a type comment. Pinning the comment like + # this avoids unstable formatting caused by comment migration. + if len(self.leaves) < 2: + comment.type = STANDALONE_COMMENT + comment.prefix = "" + return False + + last_leaf = self.leaves[-2] + self.comments.setdefault(id(last_leaf), []).append(comment) + return True + + def comments_after(self, leaf: Leaf) -> list[Leaf]: + """Generate comments that should appear directly after `leaf`.""" + return self.comments.get(id(leaf), []) + + def remove_trailing_comma(self) -> None: + """Remove the trailing comma and moves the comments attached to it.""" + trailing_comma = self.leaves.pop() + trailing_comma_comments = self.comments.pop(id(trailing_comma), []) + self.comments.setdefault(id(self.leaves[-1]), []).extend( + trailing_comma_comments + ) + + def is_complex_subscript(self, leaf: Leaf) -> bool: + """Return True iff `leaf` is part of a slice with non-trivial exprs.""" + open_lsqb = self.bracket_tracker.get_open_lsqb() + if open_lsqb is None: + return False + + subscript_start = open_lsqb.next_sibling + + if isinstance(subscript_start, Node): + if subscript_start.type == syms.listmaker: + return False + + if subscript_start.type == syms.subscriptlist: + subscript_start = child_towards(subscript_start, leaf) + + return subscript_start is not None and any( + n.type in TEST_DESCENDANTS for n in subscript_start.pre_order() + ) + + def enumerate_with_length( + self, is_reversed: bool = False + ) -> Iterator[tuple[Index, Leaf, int]]: + """Return an enumeration of leaves with their length. + + Stops prematurely on multiline strings and standalone comments. + """ + op = cast( + Callable[[Sequence[Leaf]], Iterator[tuple[Index, Leaf]]], + enumerate_reversed if is_reversed else enumerate, + ) + for index, leaf in op(self.leaves): + length = len(leaf.prefix) + len(leaf.value) + if "\n" in leaf.value: + return # Multiline strings, we can't continue. + + for comment in self.comments_after(leaf): + length += len(comment.value) + + yield index, leaf, length + + def clone(self) -> "Line": + return Line( + mode=self.mode, + depth=self.depth, + inside_brackets=self.inside_brackets, + should_split_rhs=self.should_split_rhs, + magic_trailing_comma=self.magic_trailing_comma, + ) + + def __str__(self) -> str: + """Render the line.""" + if not self: + return "\n" + + indent = " " * self.depth + leaves = iter(self.leaves) + first = next(leaves) + res = f"{first.prefix}{indent}{first.value}" + res += "".join(str(leaf) for leaf in leaves) + comments_iter = itertools.chain.from_iterable(self.comments.values()) + comments = [str(comment) for comment in comments_iter] + res += "".join(comments) + + return res + "\n" + + def __bool__(self) -> bool: + """Return True if the line has leaves or comments.""" + return bool(self.leaves or self.comments) + + +@dataclass +class RHSResult: + """Intermediate split result from a right hand split.""" + + head: Line + body: Line + tail: Line + opening_bracket: Leaf + closing_bracket: Leaf + + +@dataclass +class LinesBlock: + """Class that holds information about a block of formatted lines. + + This is introduced so that the EmptyLineTracker can look behind the standalone + comments and adjust their empty lines for class or def lines. + """ + + mode: Mode + previous_block: Optional["LinesBlock"] + original_line: Line + before: int = 0 + content_lines: list[str] = field(default_factory=list) + after: int = 0 + form_feed: bool = False + + def all_lines(self) -> list[str]: + empty_line = str(Line(mode=self.mode)) + prefix = make_simple_prefix(self.before, self.form_feed, empty_line) + return [prefix] + self.content_lines + [empty_line * self.after] + + +_WHITESPACE_TOKENS = ( + token.NEWLINE, + token.NL, + token.INDENT, + token.DEDENT, + token.COMMENT, + token.ENDMARKER, +) + + +class _DecoratedFuncInfo(NamedTuple): + """Tracks the most recently seen decorated function for overload grouping.""" + + name: str + depth: int + is_multi: bool + + +@dataclass +class EmptyLineTracker: + """Provides a stateful method that returns the number of potential extra + empty lines needed before and after the currently processed line. + + Note: this tracker works on lines that haven't been split yet. It assumes + the prefix of the first leaf consists of optional newlines. Those newlines + are consumed by `maybe_empty_lines()` and included in the computation. + """ + + mode: Mode + previous_line: Line | None = None + previous_block: LinesBlock | None = None + previous_defs: list[Line] = field(default_factory=list) + semantic_leading_comment: LinesBlock | None = None + _pyi_previous_decorated_func: _DecoratedFuncInfo | None = None + + @staticmethod + def _get_funcdef_name(node: Node | Leaf) -> str | None: + """Extract the function name from a funcdef or async_funcdef node.""" + funcdef: Node | Leaf = node + if isinstance(node, Node) and node.type == syms.async_funcdef: + for sub in node.children: + if sub.type == syms.funcdef: + funcdef = sub + break + if not isinstance(funcdef, Node) or funcdef.type != syms.funcdef: + return None + # Grammar: funcdef = 'def' NAME parameters ':' ... + name_node = funcdef.children[1] + assert isinstance(name_node, Leaf) + return name_node.value + + @staticmethod + def _decorated_node_has_func_named(node: Node, name: str) -> bool: + """Check if a ``decorated`` node contains a function with the given name.""" + return any( + sub.type in (syms.funcdef, syms.async_funcdef) + and EmptyLineTracker._get_funcdef_name(sub) == name + for sub in node.children + ) + + @staticmethod + def _find_adjacent_decorated( + node: Node | Leaf, *, reverse: bool = False + ) -> Node | None: + """Walk siblings skipping whitespace tokens, returning the first + ``decorated`` node found or ``None``.""" + sibling = node.prev_sibling if reverse else node.next_sibling + while sibling is not None: + if sibling.type == syms.decorated: + assert isinstance(sibling, Node) + return sibling + elif sibling.type in _WHITESPACE_TOKENS: + sibling = sibling.prev_sibling if reverse else sibling.next_sibling + else: + return None + return None + + @staticmethod + def _get_suite_first_decorated_funcname(suite: Node) -> str | None: + """Return the function name of the first decorated function in a suite.""" + for child in suite.children: + if isinstance(child, Node) and child.type == syms.decorated: + for sub in child.children: + if sub.type in (syms.funcdef, syms.async_funcdef): + return EmptyLineTracker._get_funcdef_name(sub) + break + if child.type not in (token.NEWLINE, token.NL, token.INDENT, token.DEDENT): + break + return None + + @staticmethod + def _if_stmt_branch_has_func_named( + if_stmt: Node, exclude_suite: Node, name: str + ) -> bool: + """Check if any branch of an ``if_stmt`` (other than *exclude_suite*) + contains a decorated function with the given *name*.""" + for child in if_stmt.children: + if not isinstance(child, Node): + continue + if child.type != syms.suite: + continue + if child is exclude_suite: + continue + for stmt in child.children: + if not isinstance(stmt, Node): + continue + if stmt.type != syms.decorated: + continue + if EmptyLineTracker._decorated_node_has_func_named(stmt, name): + return True + break + return False + + @staticmethod + def _get_def_name(line: Line) -> str | None: + """Extract the function name from a line that is a function definition.""" + if not line.is_def or not line.leaves: + return None + if line.leaves[0].value == "def": + return line.leaves[1].value + # async def: leaves = ['async', 'def', NAME, ...] + return line.leaves[2].value + + @staticmethod + def _is_line_decorated(line: Line) -> bool: + """Check if a def line is part of a decorated statement.""" + if not line.is_def or not line.leaves: + return False + return EmptyLineTracker._find_decorated_node(line) is not None + + @staticmethod + def _find_decorated_node(line: Line) -> Node | None: + """Walk up from the first leaf of a line to its ``decorated`` node.""" + if not line.leaves: + return None + node = line.leaves[0].parent + while node is not None: + if node.type == syms.decorated: + assert isinstance(node, Node) + return node + if node.type in (syms.suite, syms.file_input): + return None + node = node.parent + return None + + @staticmethod + def _get_decorator_target_name(line: Line) -> str | None: + """For a decorator line, extract the name of the function it decorates. + + Only handles decorated functions, not decorated classes. + """ + if not line.is_decorator: + return None + decorated = EmptyLineTracker._find_decorated_node(line) + if decorated is None: + return None + for child in decorated.children: + if child.type in (syms.funcdef, syms.async_funcdef): + return EmptyLineTracker._get_funcdef_name(child) + return None + + @staticmethod + def _decorator_decorates_class(line: Line) -> bool: + """Check if a decorator line decorates a class definition.""" + if not line.is_decorator: + return False + decorated = EmptyLineTracker._find_decorated_node(line) + if decorated is None: + return False + return any(child.type == syms.classdef for child in decorated.children) + + @staticmethod + def _def_is_followed_by_same_name_decorated_func( + line: Line, *, include_conditional_blocks: bool = False + ) -> bool: + """Check if a decorated function is followed by a same-name decorated func. + + If *include_conditional_blocks* is true, the next decorated function may + be inside an adjacent conditional block. + """ + name = EmptyLineTracker._get_def_name(line) + decorated = EmptyLineTracker._find_decorated_node(line) + if name is None or decorated is None: + return False + + sibling = decorated.next_sibling + while sibling is not None and sibling.type in _WHITESPACE_TOKENS: + sibling = sibling.next_sibling + + if sibling is None or not isinstance(sibling, Node): + return False + if sibling.type == syms.decorated: + return EmptyLineTracker._decorated_node_has_func_named(sibling, name) + if not include_conditional_blocks or sibling.type != syms.if_stmt: + return False + for child in sibling.children: + if not isinstance(child, Node): + continue + if child.type != syms.suite: + continue + first_decorated_funcname = ( + EmptyLineTracker._get_suite_first_decorated_funcname(child) + ) + return first_decorated_funcname == name + return False + + def _is_in_current_group(self, current_line: Line) -> bool: + """Check if current_line belongs to the same overload group being tracked.""" + prev = self._pyi_previous_decorated_func + if prev is None: + return False + cur_name = ( + self._get_decorator_target_name(current_line) + if current_line.is_decorator + else self._get_def_name(current_line) + ) + return ( + cur_name is not None + and cur_name == prev.name + and prev.depth == current_line.depth + and (current_line.is_decorator or self._is_line_decorated(current_line)) + ) + + @staticmethod + def _decorated_node_starts_group(decorated_node: Node) -> bool: + """Check if a `decorated` AST node is the first in a multi-function group. + + Returns True when the next statement-level sibling is also a decorated + function with the same name. + """ + name = None + for child in decorated_node.children: + if child.type in (syms.funcdef, syms.async_funcdef): + name = EmptyLineTracker._get_funcdef_name(child) + break + if name is None: + return False + adjacent = EmptyLineTracker._find_adjacent_decorated(decorated_node) + return adjacent is not None and EmptyLineTracker._decorated_node_has_func_named( + adjacent, name + ) + + @staticmethod + def _is_start_of_decorated_group(line: Line) -> bool: + """Check if a decorator line starts a multi-function group. + + A multi-function group is 2+ consecutive decorated functions sharing the + same name (e.g. @overload groups, @property + setter pairs). + """ + if not line.is_decorator: + return False + decorated_node = EmptyLineTracker._find_decorated_node(line) + if decorated_node is None or decorated_node.parent is None: + return False + return EmptyLineTracker._decorated_node_starts_group(decorated_node) + + @staticmethod + def _get_block_first_decorated_funcname(line: Line) -> str | None: + """Return the function name of the first decorated function in a block. + + *line* must be a block-opening line (ending with ``:``) such as + ``if ...:``. Returns ``None`` when the block doesn't start with a + decorated function. + """ + if not line.leaves or line.leaves[-1].type != token.COLON: + return None + suite = line.leaves[-1].next_sibling + if suite is None or not isinstance(suite, Node) or suite.type != syms.suite: + return None + return EmptyLineTracker._get_suite_first_decorated_funcname(suite) + + @staticmethod + def _block_is_part_of_overload_group(line: Line) -> bool: + """Check if a block-opening line contains a decorated function that is + part of a larger overload group — either because the ``if_stmt``'s next + sibling is a same-name decorated function, or because another branch of + the same ``if_stmt`` has one. + """ + func_name = EmptyLineTracker._get_block_first_decorated_funcname(line) + if func_name is None: + return False + + suite = line.leaves[-1].next_sibling + if suite is None or not isinstance(suite, Node): + return False + if_stmt = suite.parent + if if_stmt is None or not isinstance(if_stmt, Node): + return False + + # Check if the if_stmt's next sibling is a same-name decorated function. + adjacent = EmptyLineTracker._find_adjacent_decorated(if_stmt) + if adjacent is not None and EmptyLineTracker._decorated_node_has_func_named( + adjacent, func_name + ): + return True + + # Check other branches (elif/else) of the same if_stmt. + return EmptyLineTracker._if_stmt_branch_has_func_named( + if_stmt, suite, func_name + ) + + @staticmethod + def _is_decorator_in_conditional_overload(line: Line) -> bool: + """Check if a decorator is inside an if/else block that is part of a + broader overload group (a sibling or another branch of the same + ``if_stmt`` contains a same-name decorated function).""" + name = EmptyLineTracker._get_decorator_target_name(line) + if name is None: + return False + + decorated = EmptyLineTracker._find_decorated_node(line) + if decorated is None: + return False + + suite = decorated.parent + if suite is None or suite.type != syms.suite: + return False + + if_stmt = suite.parent + if if_stmt is None or if_stmt.type != syms.if_stmt: + return False + + # Check if_stmt's adjacent siblings for same-name decorated function. + for reverse in (True, False): + adjacent = EmptyLineTracker._find_adjacent_decorated( + if_stmt, reverse=reverse + ) + if ( + adjacent is not None + and EmptyLineTracker._decorated_node_has_func_named(adjacent, name) + ): + return True + + # Check other branches of the same if_stmt. + return EmptyLineTracker._if_stmt_branch_has_func_named(if_stmt, suite, name) + + def maybe_empty_lines(self, current_line: Line) -> LinesBlock: + """Return the number of extra empty lines before and after the `current_line`. + + This is for separating `def`, `async def` and `class` with extra empty + lines (two on module-level). + """ + form_feed = ( + current_line.depth == 0 + and bool(current_line.leaves) + and "\f\n" in current_line.leaves[0].prefix + ) + before, after = self._maybe_empty_lines(current_line) + previous_after = self.previous_block.after if self.previous_block else 0 + before = max(0, before - previous_after) + + # Always have one empty line after a module docstring + if self._line_is_module_docstring(current_line): + before = 1 + + block = LinesBlock( + mode=self.mode, + previous_block=self.previous_block, + original_line=current_line, + before=before, + after=after, + form_feed=form_feed, + ) + + # Maintain the semantic_leading_comment state. + if current_line.is_comment: + if self.previous_line is None or ( + not self.previous_line.is_decorator + # `or before` means this comment already has an empty line before + and (not self.previous_line.is_comment or before) + and (self.semantic_leading_comment is None or before) + ): + self.semantic_leading_comment = block + # `or before` means this decorator already has an empty line before + elif not current_line.is_decorator or before: + self.semantic_leading_comment = None + + # Maintain _pyi_previous_decorated_func state for overload groups. + # The tuple is (name, depth, is_multi) where is_multi indicates + # the group has 2+ same-name decorated functions. + overload_groups = ( + self.mode.is_pyi and Preview.pyi_overload_group_blank_lines in self.mode + ) + if overload_groups: + if current_line.is_def and self._is_line_decorated(current_line): + name = self._get_def_name(current_line) + if name is not None: + prev = self._pyi_previous_decorated_func + is_multi = ( + prev is not None + and prev.name == name + and prev.depth == current_line.depth + ) + self._pyi_previous_decorated_func = _DecoratedFuncInfo( + name=name, + depth=current_line.depth, + is_multi=is_multi + or (prev is not None and prev.name == name and prev.is_multi), + ) + elif ( + not current_line.is_decorator + and not current_line.is_comment + and ( + self._pyi_previous_decorated_func is None + or ( + current_line.depth <= self._pyi_previous_decorated_func.depth + # Don't reset on else/elif — they continue an if/else + # chain that may contain overloads at a deeper depth. + and not ( + current_line.leaves + and current_line.leaves[0].value in ("else", "elif") + ) + ) + ) + ): + # Only reset when we see a non-decorator line at the same or + # lower depth. Body lines (docstrings, ...) at deeper depth + # should not clear the state. + self._pyi_previous_decorated_func = None + + self.previous_line = current_line + self.previous_block = block + return block + + def _line_is_module_docstring(self, current_line: Line) -> bool: + previous_block = self.previous_block + if not previous_block: + return False + if ( + len(previous_block.original_line.leaves) != 1 + or not previous_block.original_line.is_docstring + or current_line.is_class + or current_line.is_def + ): + return False + while previous_block := previous_block.previous_block: + if not previous_block.original_line.is_comment: + return False + return True + + def _maybe_empty_lines(self, current_line: Line) -> tuple[int, int]: + max_allowed = 1 + if current_line.depth == 0: + max_allowed = 1 if self.mode.is_pyi else 2 + overload_groups = ( + self.mode.is_pyi and Preview.pyi_overload_group_blank_lines in self.mode + ) + + if current_line.leaves: + # Consume the first leaf's extra newlines. + first_leaf = current_line.leaves[0] + before = first_leaf.prefix.count("\n") + before = min(before, max_allowed) + first_leaf.prefix = "" + else: + before = 0 + + user_had_newline = bool(before) + depth = current_line.depth + + # Mutate self.previous_defs, remainder of this function should be pure + previous_def = None + while self.previous_defs and self.previous_defs[-1].depth >= depth: + previous_def = self.previous_defs.pop() + if current_line.is_def or current_line.is_class: + self.previous_defs.append(current_line) + + if self.previous_line is None: + # Don't insert empty lines before the first line in the file. + return 0, 0 + + if current_line.is_docstring: + if self.previous_line.is_class: + return 0, 1 + if self.previous_line.opens_block and self.previous_line.is_def: + return 0, 0 + + if previous_def is not None: + assert self.previous_line is not None + # Note: for decorator/def/class lines, `before` computed here is + # passed to _maybe_empty_lines_for_class_or_def which may override + # it. This block still matters for non-decorator/def/class lines + # (e.g. a `var: int` statement following an overload group). + if self.mode.is_pyi: + if previous_def.is_class and not previous_def.is_stub_class: + before = 1 + elif ( + overload_groups + and self._pyi_previous_decorated_func is not None + and self._pyi_previous_decorated_func.is_multi + and not current_line.is_comment + and self.previous_line.depth >= current_line.depth + and not ( + current_line.leaves + and current_line.leaves[0].value in ("else", "elif") + ) + ): + if self._is_in_current_group(current_line): + before = 0 + elif current_line.opens_block and ( + self._get_block_first_decorated_funcname(current_line) + == self._pyi_previous_decorated_func.name + ): + before = 0 + else: + before = 1 + elif ( + overload_groups + and current_line.opens_block + and current_line.leaves + and current_line.leaves[0].value in ("else", "elif") + and self._block_is_part_of_overload_group(current_line) + ): + # else/elif continuing a conditional overload group: + # don't insert a blank line above. + before = 0 + elif ( + Preview.pyi_blank_line_after_function_docstring in self.mode + and previous_def.is_def + and self.previous_line.is_docstring + and self.previous_line.depth == previous_def.depth + 1 + and not self._def_is_followed_by_same_name_decorated_func( + previous_def, + include_conditional_blocks=overload_groups, + ) + ): + before = 1 + elif depth and not current_line.is_def and self.previous_line.is_def: + if ( + overload_groups + and current_line.opens_block + and self.previous_line.depth <= current_line.depth + and self._block_is_part_of_overload_group(current_line) + ): + before = 1 + else: + # Empty lines between attributes and methods should + # be preserved. + before = 1 if user_had_newline else 0 + elif ( + overload_groups + and current_line.is_comment + and self._pyi_previous_decorated_func is not None + and self._pyi_previous_decorated_func.depth == current_line.depth + ): + # Own-line comments after a decorated function in .pyi: + # preserve a single user blank line but never insert one. + # For non-overload cases the comment_to_add_newlines + # mechanism will retroactively add needed blank lines. + before = 1 if user_had_newline else 0 + elif depth: + before = 0 + else: + before = 1 + else: + if depth: + before = 1 + elif ( + not depth + and previous_def.depth + and current_line.leaves[-1].type == token.COLON + and ( + current_line.leaves[0].value + not in ("with", "try", "for", "while", "if", "match") + ) + ): + # We shouldn't add two newlines between an indented function and + # a dependent non-indented clause. This is to avoid issues with + # conditional function definitions that are technically top-level + # and therefore get two trailing newlines, but look weird and + # inconsistent when they're followed by elif, else, etc. This is + # worse because these functions only get *one* preceding newline + # already. + before = 1 + else: + before = 2 + + if current_line.is_decorator or current_line.is_def or current_line.is_class: + return self._maybe_empty_lines_for_class_or_def( + current_line, before, user_had_newline + ) + + if ( + self.previous_line.is_import + and self.previous_line.depth == 0 + and current_line.depth == 0 + and not current_line.is_import + and not current_line.is_fmt_pass_converted(first_leaf_matches=is_import) + ): + return 1, 0 + + if ( + self.previous_line.is_import + and not current_line.is_import + and not current_line.is_fmt_pass_converted(first_leaf_matches=is_import) + and depth == self.previous_line.depth + ): + return (before or 1), 0 + + return before, 0 + + def _maybe_empty_lines_for_class_or_def( + self, current_line: Line, before: int, user_had_newline: bool + ) -> tuple[int, int]: + assert self.previous_line is not None + overload_groups = ( + self.mode.is_pyi and Preview.pyi_overload_group_blank_lines in self.mode + ) + + if self.previous_line.is_decorator: + if self.mode.is_pyi and current_line.is_stub_class: + # Insert an empty line after a decorated stub class + return 0, 1 + return 0, 0 + + if self.previous_line.depth < current_line.depth and ( + self.previous_line.is_class or self.previous_line.is_def + ): + if self.mode.is_pyi: + return 0, 0 + return 1 if user_had_newline else 0, 0 + + comment_to_add_newlines: LinesBlock | None = None + if ( + self.previous_line.is_comment + and self.previous_line.depth == current_line.depth + and before == 0 + ): + slc = self.semantic_leading_comment + if ( + slc is not None + and slc.previous_block is not None + and not slc.previous_block.original_line.is_class + and not slc.previous_block.original_line.opens_block + and slc.before <= 1 + ): + comment_to_add_newlines = slc + else: + return 0, 0 + + if self.mode.is_pyi: + if current_line.is_class or self.previous_line.is_class: + if self.previous_line.depth < current_line.depth: + newlines = 0 + elif self.previous_line.depth > current_line.depth: + newlines = 1 + elif current_line.is_stub_class and self.previous_line.is_stub_class: + # No blank line between classes with an empty body + newlines = 0 + else: + newlines = 1 + # Don't inspect only the previous line if it's part of the body of the + # preceding statement. We always want a blank line after something with a + # body. + elif self.previous_line.depth > current_line.depth: + if overload_groups and self._is_in_current_group(current_line): + newlines = 0 + else: + newlines = 1 + elif ( + overload_groups + and self._pyi_previous_decorated_func is not None + and self._pyi_previous_decorated_func.is_multi + and self.previous_line.depth >= current_line.depth + ): + newlines = 0 if self._is_in_current_group(current_line) else 1 + elif overload_groups and self._is_in_current_group(current_line): + # A comment between overloads may prevent is_multi from being + # set, but _is_in_current_group still detects name continuity. + newlines = 0 + elif ( + overload_groups + and current_line.is_decorator + and self.previous_line.depth >= current_line.depth + and self._is_start_of_decorated_group(current_line) + and ( + self._pyi_previous_decorated_func is None + or ( + self._pyi_previous_decorated_func.name + != self._get_decorator_target_name(current_line) + ) + or self._pyi_previous_decorated_func.depth != current_line.depth + ) + ): + newlines = 1 + elif ( + current_line.is_def or current_line.is_decorator + ) and not self.previous_line.is_def: + if ( + overload_groups + and current_line.is_decorator + and self.previous_line.is_comment + and self._is_decorator_in_conditional_overload(current_line) + ): + # Comment before an overload inside a conditional block: + # remove blank lines between the comment and decorator. + newlines = 0 + elif current_line.depth: + # In classes empty lines between attributes and methods should + # be preserved. + newlines = min(1, before) + else: + # Blank line between a block of functions (maybe with preceding + # decorators) and a block of non-functions + newlines = 1 + elif ( + Preview.pyi_blank_line_before_decorated_class in self.mode + and current_line.is_decorator + and self._decorator_decorates_class(current_line) + ): + newlines = 1 + else: + newlines = 0 + else: + newlines = 1 if current_line.depth else 2 + # If a user has left no space after a dummy implementation, don't insert + # new lines. This is useful for instance for @overload or Protocols. + if self.previous_line.is_stub_def and not user_had_newline: + newlines = 0 + if comment_to_add_newlines is not None: + previous_block = comment_to_add_newlines.previous_block + if previous_block is not None: + comment_to_add_newlines.before = ( + max(comment_to_add_newlines.before, newlines) - previous_block.after + ) + newlines = 0 + return newlines, 0 + + +def enumerate_reversed(sequence: Sequence[T]) -> Iterator[tuple[Index, T]]: + """Like `reversed(enumerate(sequence))` if that were possible.""" + index = len(sequence) - 1 + for element in reversed(sequence): + yield (index, element) + index -= 1 + + +def append_leaves( + new_line: Line, old_line: Line, leaves: list[Leaf], preformatted: bool = False +) -> None: + """ + Append leaves (taken from @old_line) to @new_line, making sure to fix the + underlying Node structure where appropriate. + + All of the leaves in @leaves are duplicated. The duplicates are then + appended to @new_line and used to replace their originals in the underlying + Node structure. Any comments attached to the old leaves are reattached to + the new leaves. + + Pre-conditions: + set(@leaves) is a subset of set(@old_line.leaves). + """ + # @leaves is a slice of @old_line.leaves, so the leaves are in tree (DFS) + # order and the children replaced within any one parent are reached at + # strictly increasing positions. Remembering where the last child of each + # parent was found lets the lookup resume from there instead of rescanning the + # whole child list through Base.remove on every leaf, which is otherwise + # O(n^2) when a node has many children replaced (e.g. wrapping the operand + # tuple of "%s" % (a, b, c, ...) or copying a very long line for a second + # formatting pass). + search_start: dict[int, int] = {} + for old_leaf in leaves: + new_leaf = Leaf(old_leaf.type, old_leaf.value) + parent = old_leaf.parent + if parent is not None: + children = parent.children + index = search_start.get(id(parent), 0) + while index < len(children) and children[index] is not old_leaf: + index += 1 + if index < len(children): + # set_child swaps the child in place (the old one keeps the same + # position), so the next sibling to replace is always further on. + parent.set_child(index, new_leaf) + search_start[id(parent)] = index + 1 + else: + # The resume hint missed (unexpected ordering); fall back to the + # full scan so behaviour is unchanged. + replace_child(old_leaf, new_leaf) + new_line.append(new_leaf, preformatted=preformatted) + + for comment_leaf in old_line.comments_after(old_leaf): + new_line.append(comment_leaf, preformatted=True) + + +def is_line_short_enough(line: Line, *, mode: Mode, line_str: str = "") -> bool: + """For non-multiline strings, return True if `line` is no longer than `line_length`. + For multiline strings, looks at the context around `line` to determine + if it should be inlined or split up. + Uses the provided `line_str` rendering, if any, otherwise computes a new one. + """ + if not line_str: + line_str = line_to_string(line) + + if line.contains_standalone_comments(): + return False + if "\n" not in line_str: + # No multiline strings (MLS) present + return str_width(line_str) <= mode.line_length + + first, *_, last = line_str.split("\n") + if str_width(first) > mode.line_length or str_width(last) > mode.line_length: + return False + + # Traverse the AST to examine the context of the multiline string (MLS), + # tracking aspects such as depth and comma existence, + # to determine whether to split the MLS or keep it together. + # Depth (which is based on the existing bracket_depth concept) + # is needed to determine nesting level of the MLS. + # Includes special case for trailing commas. + commas: list[int] = [] # tracks number of commas per depth level + multiline_string: Leaf | None = None + # store the leaves that contain parts of the MLS + multiline_string_contexts: list[LN] = [] + + # `id()`s of the leaves on this line, used to find which ancestors of the + # multiline string are rendered in full on this line (see below). + line_leaf_ids = {id(leaf) for leaf in line.leaves} + + max_level_to_update: int | float = math.inf # track the depth of the MLS + for i, leaf in enumerate(line.leaves): + if max_level_to_update == math.inf: + had_comma: int | None = None + if leaf.bracket_depth + 1 > len(commas): + commas.append(0) + elif leaf.bracket_depth + 1 < len(commas): + had_comma = commas.pop() + if ( + had_comma is not None + and multiline_string is not None + and multiline_string.bracket_depth == leaf.bracket_depth + 1 + ): + # Have left the level with the MLS, stop tracking commas + max_level_to_update = leaf.bracket_depth + if had_comma > 0: + # MLS was in parens with at least one comma - force split + return False + + if leaf.bracket_depth <= max_level_to_update and leaf.type == token.COMMA: + # Inside brackets, ignore trailing comma + # directly after MLS/MLS-containing expression + ignore_ctxs: list[LN | None] = [None] + ignore_ctxs += multiline_string_contexts + if (line.inside_brackets or leaf.bracket_depth > 0) and ( + i != len(line.leaves) - 1 or leaf.prev_sibling not in ignore_ctxs + ): + commas[leaf.bracket_depth] += 1 + if max_level_to_update != math.inf: + max_level_to_update = min(max_level_to_update, leaf.bracket_depth) + + if is_multiline_string(leaf): + if leaf.parent and ( + leaf.parent.type == syms.test + or (leaf.parent.parent and leaf.parent.parent.type == syms.dictsetmaker) + ): + # Keep ternary and dictionary values parenthesized + return False + if len(multiline_string_contexts) > 0: + # >1 multiline string cannot fit on a single line - force split + return False + multiline_string = leaf + ctx: LN = leaf + # fetch the leaf components of the MLS in the AST. An ancestor is + # part of the MLS context while it is rendered in full on this line, + # i.e. its first and last leaves both belong to the line (a line is + # a contiguous run of leaves). Walking the leaf ids instead of + # re-rendering `str(ctx)` and substring-searching `line_str` at every + # level keeps this linear; the old form was quadratic on lines with a + # large multiline-string-bearing collection (e.g. a dict literal with + # many triple-quoted values). + while ( + id(first_leaf(ctx)) in line_leaf_ids + and id(last_leaf(ctx)) in line_leaf_ids + ): + multiline_string_contexts.append(ctx) + if ctx.parent is None: + break + ctx = ctx.parent + + # May not have a triple-quoted multiline string at all, + # in case of a regular string with embedded newlines and line continuations + if len(multiline_string_contexts) == 0: + return True + + return all(val == 0 for val in commas) + + +def can_be_split(line: Line) -> bool: + """Return False if the line cannot be split *for sure*. + + This is not an exhaustive search but a cheap heuristic that we can use to + avoid some unfortunate formattings (mostly around wrapping unsplittable code + in unnecessary parentheses). + """ + leaves = line.leaves + if len(leaves) < 2: + return False + + if leaves[0].type == token.STRING and leaves[1].type == token.DOT: + call_count = 0 + dot_count = 0 + next = leaves[-1] + for leaf in leaves[-2::-1]: + if leaf.type in OPENING_BRACKETS: + if next.type not in CLOSING_BRACKETS: + return False + + call_count += 1 + elif leaf.type == token.DOT: + dot_count += 1 + elif leaf.type == token.NAME: + if not (next.type == token.DOT or next.type in OPENING_BRACKETS): + return False + + elif leaf.type not in CLOSING_BRACKETS: + return False + + if dot_count > 1 and call_count > 1: + return False + + return True + + +def _is_annotated_assignment(head: Line) -> bool: + """Does `head` (an assignment's leaves up to the `=`) contain an annotation? + + Detects a `:` at the top bracket level, as in `x: dict[str, int] = ...`. + Colons nested inside brackets (e.g. slices like `x[a:b]`) don't count. + """ + depth = 0 + for leaf in head.leaves: + if not leaf.value: + continue + if leaf.type in OPENING_BRACKETS: + depth += 1 + elif leaf.type in CLOSING_BRACKETS: + depth -= 1 + elif leaf.type == token.COLON and depth == 0: + return True + return False + + +def can_omit_invisible_parens( + rhs: RHSResult, + line_length: int, + mode: Mode, +) -> bool: + """Does `rhs.body` have a shape safe to reformat without optional parens around it? + + Returns True for only a subset of potentially nice looking formattings but + the point is to not return false positives that end up producing lines that + are too long. + """ + line = rhs.body + + # We can't omit parens if doing so would result in a type: ignore comment + # sharing a line with other comments, as that breaks type: ignore parsing. + # Check if the opening bracket (last leaf of head) has comments that would merge + # with comments from the first line of the body. + if rhs.head.leaves: + opening_bracket = rhs.head.leaves[-1] + head_comments = rhs.head.comments.get(id(opening_bracket), []) + + # If there are comments on the opening bracket line, check if any would + # conflict with type: ignore comments in the body + if head_comments: + has_type_ignore_in_head = any( + is_type_ignore_comment(comment, mode=rhs.head.mode) + for comment in head_comments + ) + has_other_comment_in_head = any( + not is_type_ignore_comment(comment, mode=rhs.head.mode) + for comment in head_comments + ) + + # Check for comments in the body that would potentially end up on the + # same line as the head comments when parens are removed + has_type_ignore_in_body = False + has_other_comment_in_body = False + for leaf in rhs.body.leaves: + for comment in rhs.body.comments.get(id(leaf), []): + if is_type_ignore_comment(comment, mode=rhs.body.mode): + has_type_ignore_in_body = True + else: + has_other_comment_in_body = True + + # Preserve parens if we have both type: ignore and other comments that + # could end up on the same line + if (has_type_ignore_in_head and has_other_comment_in_body) or ( + has_other_comment_in_head and has_type_ignore_in_body + ): + return False + + # We need optional parens in order to split standalone comments to their own lines + # if there are no nested parens around the standalone comments + closing_bracket: Leaf | None = None + for leaf in reversed(line.leaves): + if closing_bracket and leaf is closing_bracket.opening_bracket: + closing_bracket = None + if leaf.type == STANDALONE_COMMENT and not closing_bracket: + return False + if ( + not closing_bracket + and leaf.type in CLOSING_BRACKETS + and leaf.opening_bracket in line.leaves + and leaf.value + ): + closing_bracket = leaf + + # For assignments to a subscripted target whose head is too long to fit + # (e.g. `x[long_key][another_long_key] = expr`), the target must be split + # at its subscript brackets no matter what, so optional parens around a + # RHS that fits on the resulting tail line (`] = expr`) are unnecessary. + # When the head fits on one line, paren-wrapping the RHS remains the + # preferred style and this check must not fire. It must also come before + # the delimiter_count > 1 early return below, which would otherwise + # reject bodies with multiple delimiters such as `10 - 5`. + if ( + Preview.fix_unnecessary_parens_in_indexed_assignment in mode + and len(rhs.head.leaves) >= 3 + and rhs.head.leaves[-2].type == token.EQUAL + # The target must actually end with a subscript: a visible `]` + # immediately before the `=`. Invisible parens (e.g. around tuple + # targets like `(x,) = ...`) have an empty value and don't count. + and rhs.head.leaves[-3].type == token.RSQB + and rhs.head.leaves[-3].value + # In annotated assignments (`x: dict[str, int] = ...`) the `]` before + # the `=` belongs to the annotation; splitting on the annotation's + # brackets would be wrong, so leave the optional parens alone. + and not _is_annotated_assignment(rhs.head) + # The head must be too long to fit, forcing the subscript split. + and not is_line_short_enough(rhs.head, mode=mode) + ): + # 4 extra characters for the `] = ` prefix on the tail line. + tail_line_length = 4 * line.depth + 4 + for _index, _leaf, leaf_length in line.enumerate_with_length(): + tail_line_length += leaf_length + if tail_line_length <= line_length: + return True + + bt = line.bracket_tracker + if not bt.delimiters: + # Without delimiters the optional parentheses are useless. + return True + + max_priority = bt.max_delimiter_priority() + delimiter_count = bt.delimiter_count_with_priority(max_priority) + if delimiter_count > 1: + # With more than one delimiter of a kind the optional parentheses read better. + return False + + if delimiter_count == 1: + if max_priority == COMMA_PRIORITY and rhs.head.is_with_or_async_with_stmt: + # For two context manager with statements, the optional parentheses read + # better. In this case, `rhs.body` is the context managers part of + # the with statement. `rhs.head` is the `with (` part on the previous + # line. + return False + # Otherwise it may also read better, but we don't do it today and requires + # careful considerations for all possible cases. See + # https://github.com/psf/black/issues/2156. + + if max_priority == DOT_PRIORITY: + # A single stranded method call doesn't require optional parentheses. + return True + + assert len(line.leaves) >= 2, "Stranded delimiter" + + # With a single delimiter, omit if the expression starts or ends with + # a bracket. + first = line.leaves[0] + second = line.leaves[1] + if first.type in OPENING_BRACKETS and second.type not in CLOSING_BRACKETS: + if _can_omit_opening_paren(line, first=first, line_length=line_length): + return True + + # Note: we are not returning False here because a line might have *both* + # a leading opening bracket and a trailing closing bracket. If the + # opening bracket doesn't match our rule, maybe the closing will. + + penultimate = line.leaves[-2] + last = line.leaves[-1] + + if ( + last.type == token.RPAR + or last.type == token.RBRACE + or ( + # don't use indexing for omitting optional parentheses; + # it looks weird + last.type == token.RSQB + and last.parent + and last.parent.type != syms.trailer + ) + ): + if penultimate.type in OPENING_BRACKETS: + # Empty brackets don't help. + return False + + if is_multiline_string(first): + # Additional wrapping of a multiline string in this situation is + # unnecessary. + return True + + if _can_omit_closing_paren(line, last=last, line_length=line_length): + return True + + return False + + +def _can_omit_opening_paren(line: Line, *, first: Leaf, line_length: int) -> bool: + """See `can_omit_invisible_parens`.""" + remainder = False + length = 4 * line.depth + _index = -1 + for _index, leaf, leaf_length in line.enumerate_with_length(): + if leaf.type in CLOSING_BRACKETS and leaf.opening_bracket is first: + remainder = True + if remainder: + length += leaf_length + if length > line_length: + break + + if leaf.type in OPENING_BRACKETS: + # There are brackets we can further split on. + remainder = False + + else: + # checked the entire string and line length wasn't exceeded + if len(line.leaves) == _index + 1: + return True + + return False + + +def _can_omit_closing_paren(line: Line, *, last: Leaf, line_length: int) -> bool: + """See `can_omit_invisible_parens`.""" + length = 4 * line.depth + seen_other_brackets = False + for _index, leaf, leaf_length in line.enumerate_with_length(): + length += leaf_length + if leaf is last.opening_bracket: + if seen_other_brackets or length <= line_length: + return True + + elif leaf.type in OPENING_BRACKETS: + # There are brackets we can further split on. + seen_other_brackets = True + + return False + + +def line_to_string(line: Line) -> str: + """Returns the string representation of @line. + + WARNING: This is known to be computationally expensive. + """ + return str(line).strip("\n") diff --git a/src/black/mode.py b/src/black/mode.py new file mode 100644 index 0000000..9646f21 --- /dev/null +++ b/src/black/mode.py @@ -0,0 +1,354 @@ +"""Data structures configuring Black behavior. + +Mostly around Python language feature support per version and Black configuration +chosen by the user. +""" + +from dataclasses import dataclass, field +from enum import Enum, auto +from hashlib import sha256 +from operator import attrgetter +from typing import Final + +from black.const import DEFAULT_LINE_LENGTH + + +class TargetVersion(Enum): + PY33 = 3 + PY34 = 4 + PY35 = 5 + PY36 = 6 + PY37 = 7 + PY38 = 8 + PY39 = 9 + PY310 = 10 + PY311 = 11 + PY312 = 12 + PY313 = 13 + PY314 = 14 + PY315 = 15 + + def pretty(self) -> str: + assert self.name[:2] == "PY" + return f"Python {self.name[2]}.{self.name[3:]}" + + +class Feature(Enum): + F_STRINGS = 2 + NUMERIC_UNDERSCORES = 3 + TRAILING_COMMA_IN_CALL = 4 + TRAILING_COMMA_IN_DEF = 5 + # The following two feature-flags are mutually exclusive, and exactly one should be + # set for every version of python. + ASYNC_IDENTIFIERS = 6 + ASYNC_KEYWORDS = 7 + ASSIGNMENT_EXPRESSIONS = 8 + POS_ONLY_ARGUMENTS = 9 + RELAXED_DECORATORS = 10 + PATTERN_MATCHING = 11 + UNPACKING_ON_FLOW = 12 + ANN_ASSIGN_EXTENDED_RHS = 13 + EXCEPT_STAR = 14 + VARIADIC_GENERICS = 15 + DEBUG_F_STRINGS = 16 + PARENTHESIZED_CONTEXT_MANAGERS = 17 + TYPE_PARAMS = 18 + # FSTRING_PARSING = 19 # unused + TYPE_PARAM_DEFAULTS = 20 + UNPARENTHESIZED_EXCEPT_TYPES = 21 + T_STRINGS = 22 + LAZY_IMPORTS = 23 + UNPACKING_IN_COMPREHENSIONS = 24 + FORCE_OPTIONAL_PARENTHESES = 50 + + # __future__ flags + FUTURE_ANNOTATIONS = 51 + + +FUTURE_FLAG_TO_FEATURE: Final = { + "annotations": Feature.FUTURE_ANNOTATIONS, +} + + +VERSION_TO_FEATURES: dict[TargetVersion, set[Feature]] = { + TargetVersion.PY33: {Feature.ASYNC_IDENTIFIERS}, + TargetVersion.PY34: {Feature.ASYNC_IDENTIFIERS}, + TargetVersion.PY35: {Feature.TRAILING_COMMA_IN_CALL, Feature.ASYNC_IDENTIFIERS}, + TargetVersion.PY36: { + Feature.F_STRINGS, + Feature.NUMERIC_UNDERSCORES, + Feature.TRAILING_COMMA_IN_CALL, + Feature.TRAILING_COMMA_IN_DEF, + Feature.ASYNC_IDENTIFIERS, + }, + TargetVersion.PY37: { + Feature.F_STRINGS, + Feature.NUMERIC_UNDERSCORES, + Feature.TRAILING_COMMA_IN_CALL, + Feature.TRAILING_COMMA_IN_DEF, + Feature.ASYNC_KEYWORDS, + Feature.FUTURE_ANNOTATIONS, + }, + TargetVersion.PY38: { + Feature.F_STRINGS, + Feature.DEBUG_F_STRINGS, + Feature.NUMERIC_UNDERSCORES, + Feature.TRAILING_COMMA_IN_CALL, + Feature.TRAILING_COMMA_IN_DEF, + Feature.ASYNC_KEYWORDS, + Feature.FUTURE_ANNOTATIONS, + Feature.ASSIGNMENT_EXPRESSIONS, + Feature.POS_ONLY_ARGUMENTS, + Feature.UNPACKING_ON_FLOW, + Feature.ANN_ASSIGN_EXTENDED_RHS, + }, + TargetVersion.PY39: { + Feature.F_STRINGS, + Feature.DEBUG_F_STRINGS, + Feature.NUMERIC_UNDERSCORES, + Feature.TRAILING_COMMA_IN_CALL, + Feature.TRAILING_COMMA_IN_DEF, + Feature.ASYNC_KEYWORDS, + Feature.FUTURE_ANNOTATIONS, + Feature.ASSIGNMENT_EXPRESSIONS, + Feature.RELAXED_DECORATORS, + Feature.POS_ONLY_ARGUMENTS, + Feature.UNPACKING_ON_FLOW, + Feature.ANN_ASSIGN_EXTENDED_RHS, + Feature.PARENTHESIZED_CONTEXT_MANAGERS, + }, + TargetVersion.PY310: { + Feature.F_STRINGS, + Feature.DEBUG_F_STRINGS, + Feature.NUMERIC_UNDERSCORES, + Feature.TRAILING_COMMA_IN_CALL, + Feature.TRAILING_COMMA_IN_DEF, + Feature.ASYNC_KEYWORDS, + Feature.FUTURE_ANNOTATIONS, + Feature.ASSIGNMENT_EXPRESSIONS, + Feature.RELAXED_DECORATORS, + Feature.POS_ONLY_ARGUMENTS, + Feature.UNPACKING_ON_FLOW, + Feature.ANN_ASSIGN_EXTENDED_RHS, + Feature.PARENTHESIZED_CONTEXT_MANAGERS, + Feature.PATTERN_MATCHING, + }, + TargetVersion.PY311: { + Feature.F_STRINGS, + Feature.DEBUG_F_STRINGS, + Feature.NUMERIC_UNDERSCORES, + Feature.TRAILING_COMMA_IN_CALL, + Feature.TRAILING_COMMA_IN_DEF, + Feature.ASYNC_KEYWORDS, + Feature.FUTURE_ANNOTATIONS, + Feature.ASSIGNMENT_EXPRESSIONS, + Feature.RELAXED_DECORATORS, + Feature.POS_ONLY_ARGUMENTS, + Feature.UNPACKING_ON_FLOW, + Feature.ANN_ASSIGN_EXTENDED_RHS, + Feature.PARENTHESIZED_CONTEXT_MANAGERS, + Feature.PATTERN_MATCHING, + Feature.EXCEPT_STAR, + Feature.VARIADIC_GENERICS, + }, + TargetVersion.PY312: { + Feature.F_STRINGS, + Feature.DEBUG_F_STRINGS, + Feature.NUMERIC_UNDERSCORES, + Feature.TRAILING_COMMA_IN_CALL, + Feature.TRAILING_COMMA_IN_DEF, + Feature.ASYNC_KEYWORDS, + Feature.FUTURE_ANNOTATIONS, + Feature.ASSIGNMENT_EXPRESSIONS, + Feature.RELAXED_DECORATORS, + Feature.POS_ONLY_ARGUMENTS, + Feature.UNPACKING_ON_FLOW, + Feature.ANN_ASSIGN_EXTENDED_RHS, + Feature.PARENTHESIZED_CONTEXT_MANAGERS, + Feature.PATTERN_MATCHING, + Feature.EXCEPT_STAR, + Feature.VARIADIC_GENERICS, + Feature.TYPE_PARAMS, + }, + TargetVersion.PY313: { + Feature.F_STRINGS, + Feature.DEBUG_F_STRINGS, + Feature.NUMERIC_UNDERSCORES, + Feature.TRAILING_COMMA_IN_CALL, + Feature.TRAILING_COMMA_IN_DEF, + Feature.ASYNC_KEYWORDS, + Feature.FUTURE_ANNOTATIONS, + Feature.ASSIGNMENT_EXPRESSIONS, + Feature.RELAXED_DECORATORS, + Feature.POS_ONLY_ARGUMENTS, + Feature.UNPACKING_ON_FLOW, + Feature.ANN_ASSIGN_EXTENDED_RHS, + Feature.PARENTHESIZED_CONTEXT_MANAGERS, + Feature.PATTERN_MATCHING, + Feature.EXCEPT_STAR, + Feature.VARIADIC_GENERICS, + Feature.TYPE_PARAMS, + Feature.TYPE_PARAM_DEFAULTS, + }, + TargetVersion.PY314: { + Feature.F_STRINGS, + Feature.DEBUG_F_STRINGS, + Feature.NUMERIC_UNDERSCORES, + Feature.TRAILING_COMMA_IN_CALL, + Feature.TRAILING_COMMA_IN_DEF, + Feature.ASYNC_KEYWORDS, + Feature.FUTURE_ANNOTATIONS, + Feature.ASSIGNMENT_EXPRESSIONS, + Feature.RELAXED_DECORATORS, + Feature.POS_ONLY_ARGUMENTS, + Feature.UNPACKING_ON_FLOW, + Feature.ANN_ASSIGN_EXTENDED_RHS, + Feature.PARENTHESIZED_CONTEXT_MANAGERS, + Feature.PATTERN_MATCHING, + Feature.EXCEPT_STAR, + Feature.VARIADIC_GENERICS, + Feature.TYPE_PARAMS, + Feature.TYPE_PARAM_DEFAULTS, + Feature.UNPARENTHESIZED_EXCEPT_TYPES, + Feature.T_STRINGS, + }, + TargetVersion.PY315: { + Feature.F_STRINGS, + Feature.DEBUG_F_STRINGS, + Feature.NUMERIC_UNDERSCORES, + Feature.TRAILING_COMMA_IN_CALL, + Feature.TRAILING_COMMA_IN_DEF, + Feature.ASYNC_KEYWORDS, + Feature.FUTURE_ANNOTATIONS, + Feature.ASSIGNMENT_EXPRESSIONS, + Feature.RELAXED_DECORATORS, + Feature.POS_ONLY_ARGUMENTS, + Feature.UNPACKING_ON_FLOW, + Feature.ANN_ASSIGN_EXTENDED_RHS, + Feature.PARENTHESIZED_CONTEXT_MANAGERS, + Feature.PATTERN_MATCHING, + Feature.EXCEPT_STAR, + Feature.VARIADIC_GENERICS, + Feature.TYPE_PARAMS, + Feature.TYPE_PARAM_DEFAULTS, + Feature.UNPARENTHESIZED_EXCEPT_TYPES, + Feature.T_STRINGS, + Feature.LAZY_IMPORTS, + Feature.UNPACKING_IN_COMPREHENSIONS, + }, +} + + +def supports_feature(target_versions: set[TargetVersion], feature: Feature) -> bool: + if not target_versions: + raise ValueError("At least one target Python version must be specified.") + + return all(feature in VERSION_TO_FEATURES[version] for version in target_versions) + + +class Preview(Enum): + """Individual preview style features.""" + + # NOTE: string_processing requires wrap_long_dict_values_in_parens + # for https://github.com/psf/black/issues/3117 to be fixed. + string_processing = auto() + hug_parens_with_braces_and_square_brackets = auto() + wrap_comprehension_in = auto() + simplify_power_operator_hugging = auto() + wrap_long_dict_values_in_parens = auto() + fix_if_guard_explosion_in_case_statement = auto() + pyi_overload_group_blank_lines = auto() + fix_unnecessary_parens_in_indexed_assignment = auto() + pyi_blank_line_before_decorated_class = auto() + pyi_blank_line_after_function_docstring = auto() + hug_comparator = auto() + parenthesize_tuple_in_yield = auto() + + +UNSTABLE_FEATURES: set[Preview] = { + # Many issues, see summary in https://github.com/psf/black/issues/4208 + Preview.string_processing, + # See issue #4036 (crash), #4098, #4099 (proposed tweaks) + Preview.hug_parens_with_braces_and_square_brackets, +} + + +_MAX_CACHE_KEY_PART_LENGTH: Final = 32 + + +@dataclass +class Mode: + target_versions: set[TargetVersion] = field(default_factory=set) + line_length: int = DEFAULT_LINE_LENGTH + string_normalization: bool = True + is_pyi: bool = False + is_ipynb: bool = False + skip_source_first_line: bool = False + magic_trailing_comma: bool = True + python_cell_magics: set[str] = field(default_factory=set) + preview: bool = False + unstable: bool = False + enabled_features: set[Preview] = field(default_factory=set) + + def __contains__(self, feature: Preview) -> bool: + """ + Provide `Preview.FEATURE in Mode` syntax that mirrors the ``preview`` flag. + + In unstable mode, all features are enabled. In preview mode, all features + except those in UNSTABLE_FEATURES are enabled. Any features in + `self.enabled_features` are also enabled. + """ + if self.unstable: + return True + if feature in self.enabled_features: + return True + return self.preview and feature not in UNSTABLE_FEATURES + + def get_cache_key(self) -> str: + if self.target_versions: + version_str = ",".join( + str(version.value) + for version in sorted(self.target_versions, key=attrgetter("value")) + ) + else: + version_str = "-" + if len(version_str) > _MAX_CACHE_KEY_PART_LENGTH: + version_str = sha256(version_str.encode()).hexdigest()[ + :_MAX_CACHE_KEY_PART_LENGTH + ] + features_and_magics = ( + ",".join(sorted(f.name for f in self.enabled_features)) + + "@" + + ",".join(sorted(self.python_cell_magics)) + ) + features_and_magics = sha256(features_and_magics.encode()).hexdigest()[ + :_MAX_CACHE_KEY_PART_LENGTH + ] + parts = [ + version_str, + str(self.line_length), + str(int(self.string_normalization)), + str(int(self.is_pyi)), + str(int(self.is_ipynb)), + str(int(self.skip_source_first_line)), + str(int(self.magic_trailing_comma)), + str(int(self.preview)), + str(int(self.unstable)), + features_and_magics, + ] + return ".".join(parts) + + def __hash__(self) -> int: + return hash(( + frozenset(self.target_versions), + self.line_length, + self.string_normalization, + self.is_pyi, + self.is_ipynb, + self.skip_source_first_line, + self.magic_trailing_comma, + frozenset(self.python_cell_magics), + self.preview, + self.unstable, + frozenset(self.enabled_features), + )) diff --git a/src/black/nodes.py b/src/black/nodes.py new file mode 100644 index 0000000..bbad5ba --- /dev/null +++ b/src/black/nodes.py @@ -0,0 +1,1142 @@ +""" +blib2to3 Node/Leaf transformation-related utility functions. +""" + +from collections.abc import Iterator +from typing import Final, Generic, Literal, TypeGuard, TypeVar, Union + +from mypy_extensions import mypyc_attr + +from black.cache import CACHE_DIR +from black.mode import Mode, Preview +from black.strings import get_string_prefix, has_triple_quotes +from blib2to3 import pygram +from blib2to3.pgen2 import token +from blib2to3.pytree import NL, Leaf, Node, type_repr + +pygram.initialize(CACHE_DIR) +syms: Final = pygram.python_symbols + + +# types +T = TypeVar("T") +LN = Union[Leaf, Node] +LeafID = int +NodeType = int + + +WHITESPACE: Final = {token.DEDENT, token.INDENT, token.NEWLINE} +STATEMENT: Final = { + syms.if_stmt, + syms.while_stmt, + syms.for_stmt, + syms.try_stmt, + syms.except_clause, + syms.with_stmt, + syms.funcdef, + syms.classdef, + syms.match_stmt, + syms.case_block, +} +STANDALONE_COMMENT: Final = 153 +token.tok_name[STANDALONE_COMMENT] = "STANDALONE_COMMENT" +LOGIC_OPERATORS: Final = {"and", "or"} +COMPARATORS: Final = { + token.LESS, + token.GREATER, + token.EQEQUAL, + token.NOTEQUAL, + token.LESSEQUAL, + token.GREATEREQUAL, +} +MATH_OPERATORS: Final = { + token.VBAR, + token.CIRCUMFLEX, + token.AMPER, + token.LEFTSHIFT, + token.RIGHTSHIFT, + token.PLUS, + token.MINUS, + token.STAR, + token.SLASH, + token.DOUBLESLASH, + token.PERCENT, + token.AT, + token.TILDE, + token.DOUBLESTAR, +} +STARS: Final = {token.STAR, token.DOUBLESTAR} +VARARGS_SPECIALS: Final = STARS | {token.SLASH} +VARARGS_PARENTS: Final = { + syms.arglist, + syms.argument, # double star in arglist + syms.trailer, # single argument to call + syms.typedargslist, + syms.varargslist, # lambdas +} +UNPACKING_PARENTS: Final = { + syms.atom, # single element of a list or set literal + syms.dictsetmaker, + syms.listmaker, + syms.testlist_gexp, + syms.testlist_star_expr, + syms.subject_expr, + syms.pattern, +} +TEST_DESCENDANTS: Final = { + syms.test, + syms.lambdef, + syms.or_test, + syms.and_test, + syms.not_test, + syms.comparison, + syms.star_expr, + syms.expr, + syms.xor_expr, + syms.and_expr, + syms.shift_expr, + syms.arith_expr, + syms.trailer, + syms.term, + syms.power, + syms.namedexpr_test, +} +TYPED_NAMES: Final = {syms.tname, syms.tname_star} +ASSIGNMENTS: Final = { + "=", + "+=", + "-=", + "*=", + "@=", + "/=", + "%=", + "&=", + "|=", + "^=", + "<<=", + ">>=", + "**=", + "//=", + ":", +} + +IMPLICIT_TUPLE: Final = {syms.testlist, syms.testlist_star_expr, syms.exprlist} +BRACKET: Final = { + token.LPAR: token.RPAR, + token.LSQB: token.RSQB, + token.LBRACE: token.RBRACE, +} +OPENING_BRACKETS: Final = set(BRACKET.keys()) +CLOSING_BRACKETS: Final = set(BRACKET.values()) +BRACKETS: Final = OPENING_BRACKETS | CLOSING_BRACKETS +ALWAYS_NO_SPACE: Final = CLOSING_BRACKETS | { + token.COMMA, + STANDALONE_COMMENT, + token.FSTRING_MIDDLE, + token.FSTRING_END, + token.TSTRING_MIDDLE, + token.TSTRING_END, + token.BANG, +} + +RARROW = 55 + + +@mypyc_attr(allow_interpreted_subclasses=True) +class Visitor(Generic[T]): + """Basic lib2to3 visitor that yields things of type `T` on `visit()`.""" + + def visit(self, node: LN) -> Iterator[T]: + """Main method to visit `node` and its children. + + It tries to find a `visit_*()` method for the given `node.type`, like + `visit_simple_stmt` for Node objects or `visit_INDENT` for Leaf objects. + If no dedicated `visit_*()` method is found, chooses `visit_default()` + instead. + + Then yields objects of type `T` from the selected visitor. + """ + if node.type < 256: + name = token.tok_name[node.type] + else: + name = str(type_repr(node.type)) + # We explicitly branch on whether a visitor exists (instead of + # using self.visit_default as the default arg to getattr) in order + # to save needing to create a bound method object and so mypyc can + # generate a native call to visit_default. + visitf = getattr(self, f"visit_{name}", None) + if visitf: + yield from visitf(node) + else: + yield from self.visit_default(node) + + def visit_default(self, node: LN) -> Iterator[T]: + """Default `visit_*()` implementation. Recurses to children of `node`.""" + if isinstance(node, Node): + for child in node.children: + yield from self.visit(child) + + +def whitespace(leaf: Leaf, *, complex_subscript: bool, mode: Mode) -> str: + """Return whitespace prefix if needed for the given `leaf`. + + `complex_subscript` signals whether the given leaf is part of a subscription + which has non-trivial arguments, like arithmetic expressions or function calls. + """ + NO: Final[str] = "" + SPACE: Final[str] = " " + DOUBLESPACE: Final[str] = " " + t = leaf.type + p = leaf.parent + v = leaf.value + if t in ALWAYS_NO_SPACE: + return NO + + if t == token.COMMENT: + return DOUBLESPACE + + assert p is not None, f"INTERNAL ERROR: hand-made leaf without parent: {leaf!r}" + if t == token.COLON and p.type not in { + syms.subscript, + syms.subscriptlist, + syms.sliceop, + }: + return NO + + if t == token.LBRACE and p.type in ( + syms.fstring_replacement_field, + syms.tstring_replacement_field, + ): + return NO + + prev = leaf.prev_sibling + if not prev: + prevp = preceding_leaf(p) + if not prevp or prevp.type in OPENING_BRACKETS: + return NO + + if t == token.COLON: + if prevp.type == token.COLON: + return NO + + elif prevp.type != token.COMMA and not complex_subscript: + return NO + + return SPACE + + if prevp.type == token.EQUAL: + if prevp.parent: + if prevp.parent.type in { + syms.arglist, + syms.argument, + syms.parameters, + syms.varargslist, + }: + return NO + + elif prevp.parent.type == syms.typedargslist: + # A bit hacky: if the equal sign has whitespace, it means we + # previously found it's a typed argument. So, we're using + # that, too. + return prevp.prefix + + elif ( + prevp.type == token.STAR + and parent_type(prevp) == syms.star_expr + and parent_type(prevp.parent) in (syms.subscriptlist, syms.tname_star) + ): + # No space between typevar tuples or unpacking them. + return NO + + elif prevp.type in VARARGS_SPECIALS: + if is_vararg(prevp, within=VARARGS_PARENTS | UNPACKING_PARENTS): + return NO + + elif prevp.type == token.COLON: + if prevp.parent and prevp.parent.type in {syms.subscript, syms.sliceop}: + return SPACE if complex_subscript else NO + + elif ( + prevp.parent + and prevp.parent.type == syms.factor + and prevp.type in MATH_OPERATORS + ): + return NO + + elif prevp.type == token.AT and p.parent and p.parent.type == syms.decorator: + # no space in decorators + return NO + + elif prev.type in OPENING_BRACKETS: + return NO + + elif prev.type == token.BANG: + return NO + + if p.type in {syms.parameters, syms.arglist}: + # untyped function signatures or calls + if not prev or prev.type != token.COMMA: + return NO + + elif p.type == syms.varargslist: + # lambdas + if prev and prev.type != token.COMMA: + return NO + + elif p.type == syms.typedargslist: + # typed function signatures + if not prev: + return NO + + if t == token.EQUAL: + if prev.type not in TYPED_NAMES: + return NO + + elif prev.type == token.EQUAL: + # A bit hacky: if the equal sign has whitespace, it means we + # previously found it's a typed argument. So, we're using that, too. + return prev.prefix + + elif prev.type != token.COMMA: + return NO + + elif p.type in TYPED_NAMES: + # type names + if not prev: + prevp = preceding_leaf(p) + if not prevp or prevp.type != token.COMMA: + return NO + + elif p.type == syms.trailer: + # attributes and calls + if t == token.LPAR or t == token.RPAR: + return NO + + if not prev: + if t == token.DOT or t == token.LSQB: + return NO + + elif prev.type != token.COMMA: + return NO + + elif p.type == syms.argument: + # single argument + if t == token.EQUAL: + return NO + + if not prev: + prevp = preceding_leaf(p) + if not prevp or prevp.type == token.LPAR: + return NO + + elif prev.type in {token.EQUAL} | VARARGS_SPECIALS: + return NO + + elif p.type == syms.decorator: + # decorators + return NO + + elif p.type == syms.dotted_name: + if prev: + return NO + + prevp = preceding_leaf(p) + if not prevp or prevp.type == token.AT or prevp.type == token.DOT: + return NO + + elif p.type == syms.classdef: + if t == token.LPAR: + return NO + + if prev and prev.type == token.LPAR: + return NO + + elif p.type in {syms.subscript, syms.sliceop}: + # indexing + if not prev: + assert p.parent is not None, "subscripts are always parented" + if p.parent.type == syms.subscriptlist: + return SPACE + + return NO + + elif t == token.COLONEQUAL or prev.type == token.COLONEQUAL: + return SPACE + + elif not complex_subscript: + return NO + + elif p.type == syms.atom: + if prev and t == token.DOT: + # dots, but not the first one. + return NO + + elif p.type == syms.dictsetmaker: + # dict unpacking + if prev and prev.type == token.DOUBLESTAR: + return NO + + elif p.type in {syms.factor, syms.star_expr}: + # unary ops + if not prev: + prevp = preceding_leaf(p) + if not prevp or prevp.type in OPENING_BRACKETS: + return NO + + prevp_parent = prevp.parent + assert prevp_parent is not None + if prevp.type == token.COLON and prevp_parent.type in { + syms.subscript, + syms.sliceop, + }: + return NO + + elif prevp.type == token.EQUAL and prevp_parent.type == syms.argument: + return NO + + elif t in {token.NAME, token.NUMBER, token.STRING}: + return NO + + elif p.type == syms.import_from: + if t == token.DOT: + if prev and prev.type == token.DOT: + return NO + + elif t == token.NAME: + if v == "import": + return SPACE + + if prev and prev.type == token.DOT: + return NO + + elif p.type == syms.sliceop: + return NO + + elif p.type == syms.except_clause: + if t == token.STAR: + return NO + + if Preview.simplify_power_operator_hugging in mode: + # Power operator hugging + if t == token.DOUBLESTAR and is_simple_exponentiation(p): + return NO + prevp = preceding_leaf(leaf) + if prevp and prevp.type == token.DOUBLESTAR: + if prevp.parent and is_simple_exponentiation(prevp.parent): + return NO + + return SPACE + + +def make_simple_prefix(nl_count: int, form_feed: bool, empty_line: str = "\n") -> str: + """Generate a normalized prefix string.""" + if form_feed: + return (empty_line * (nl_count - 1)) + "\f" + empty_line + return empty_line * nl_count + + +def preceding_leaf(node: LN | None) -> Leaf | None: + """Return the first leaf that precedes `node`, if any.""" + while node: + res = node.prev_sibling + if res: + if isinstance(res, Leaf): + return res + + try: + return list(res.leaves())[-1] + + except IndexError: + return None + + node = node.parent + return None + + +def prev_siblings_are(node: LN | None, tokens: list[NodeType | None]) -> bool: + """Return if the `node` and its previous siblings match types against the provided + list of tokens; the provided `node`has its type matched against the last element in + the list. `None` can be used as the first element to declare that the start of the + list is anchored at the start of its parent's children.""" + if not tokens: + return True + if tokens[-1] is None: + return node is None + if not node: + return False + if node.type != tokens[-1]: + return False + return prev_siblings_are(node.prev_sibling, tokens[:-1]) + + +def parent_type(node: LN | None) -> NodeType | None: + """ + Returns: + @node.parent.type, if @node is not None and has a parent. + OR + None, otherwise. + """ + if node is None or node.parent is None: + return None + + return node.parent.type + + +def child_towards(ancestor: Node, descendant: LN) -> LN | None: + """Return the child of `ancestor` that contains `descendant`.""" + node: LN | None = descendant + while node and node.parent != ancestor: + node = node.parent + return node + + +def replace_child(old_child: LN, new_child: LN) -> None: + """ + Side Effects: + * If @old_child.parent is set, replace @old_child with @new_child in + @old_child's underlying Node structure. + OR + * Otherwise, this function does nothing. + """ + parent = old_child.parent + if not parent: + return + + child_idx = old_child.remove() + if child_idx is not None: + parent.insert_child(child_idx, new_child) + + +def container_of(leaf: Leaf) -> LN: + """Return `leaf` or one of its ancestors that is the topmost container of it. + + By "container" we mean a node where `leaf` is the very first child. + """ + same_prefix = leaf.prefix + container: LN = leaf + while container: + parent = container.parent + if parent is None: + break + + if parent.children[0].prefix != same_prefix: + break + + if parent.type == syms.file_input: + break + + if parent.prev_sibling is not None and parent.prev_sibling.type in BRACKETS: + break + + container = parent + return container + + +def first_leaf_of(node: LN) -> Leaf | None: + """Returns the first leaf of the node tree.""" + if isinstance(node, Leaf): + return node + if node.children: + return first_leaf_of(node.children[0]) + else: + return None + + +def is_arith_like(node: LN) -> bool: + """Whether node is an arithmetic or a binary arithmetic expression""" + return node.type in { + syms.arith_expr, + syms.shift_expr, + syms.xor_expr, + syms.and_expr, + } + + +def is_simple_exponentiation(node: LN) -> bool: + """Whether whitespace around `**` should be removed.""" + + def is_simple(node: LN) -> bool: + if isinstance(node, Leaf): + return node.type in (token.NAME, token.NUMBER, token.DOT, token.DOUBLESTAR) + elif node.type == syms.factor: # unary operators + return is_simple(node.children[1]) + else: + return all(is_simple(child) for child in node.children) + + return ( + node.type == syms.power + and len(node.children) >= 3 + and node.children[-2].type == token.DOUBLESTAR + and is_simple(node) + ) + + +def is_docstring(node: NL) -> bool: + if isinstance(node, Leaf): + if node.type != token.STRING: + return False + + prefix = get_string_prefix(node.value) + if set(prefix).intersection("bBfF"): + return False + + if ( + node.parent + and node.parent.type == syms.simple_stmt + and not node.parent.prev_sibling + and node.parent.parent + and node.parent.parent.type == syms.file_input + ): + return True + + if prev_siblings_are( + node.parent, [None, token.NEWLINE, token.INDENT, syms.simple_stmt] + ): + return True + + # Multiline docstring on the same line as the `def`. + if prev_siblings_are(node.parent, [syms.parameters, token.COLON, syms.simple_stmt]): + # `syms.parameters` is only used in funcdefs and async_funcdefs in the Python + # grammar. We're safe to return True without further checks. + return True + + return False + + +def is_empty_tuple(node: LN) -> bool: + """Return True if `node` holds an empty tuple.""" + return ( + node.type == syms.atom + and len(node.children) == 2 + and node.children[0].type == token.LPAR + and node.children[1].type == token.RPAR + ) + + +def is_one_tuple(node: LN) -> bool: + """Return True if `node` holds a tuple with one element, with or without parens.""" + if node.type == syms.atom: + gexp = unwrap_singleton_parenthesis(node) + if gexp is None or gexp.type != syms.testlist_gexp: + return False + + return len(gexp.children) == 2 and gexp.children[1].type == token.COMMA + + return ( + node.type in IMPLICIT_TUPLE + and len(node.children) == 2 + and node.children[1].type == token.COMMA + ) + + +def is_tuple(node: LN) -> bool: + """Return True if `node` holds a tuple.""" + if node.type != syms.atom: + return False + gexp = unwrap_singleton_parenthesis(node) + if gexp is None or gexp.type != syms.testlist_gexp: + return False + + return True + + +def is_tuple_containing_walrus(node: LN) -> bool: + """Return True if `node` holds a tuple that contains a walrus operator.""" + if node.type != syms.atom: + return False + gexp = unwrap_singleton_parenthesis(node) + if gexp is None or gexp.type != syms.testlist_gexp: + return False + + return any(child.type == syms.namedexpr_test for child in gexp.children) + + +def is_tuple_containing_star(node: LN) -> bool: + """Return True if `node` holds a tuple that contains a star operator.""" + if node.type != syms.atom: + return False + gexp = unwrap_singleton_parenthesis(node) + if gexp is None or gexp.type != syms.testlist_gexp: + return False + + return any(child.type == syms.star_expr for child in gexp.children) + + +def is_generator(node: LN) -> bool: + """Return True if `node` holds a generator.""" + if node.type != syms.atom: + return False + gexp = unwrap_singleton_parenthesis(node) + if gexp is None or gexp.type != syms.testlist_gexp: + return False + + return any(child.type == syms.old_comp_for for child in gexp.children) + + +def is_one_sequence_between( + opening: Leaf, + closing: Leaf, + leaves: list[Leaf], + brackets: tuple[int, int] = (token.LPAR, token.RPAR), +) -> bool: + """Return True if content between `opening` and `closing` is a one-sequence.""" + if (opening.type, closing.type) != brackets: + return False + + depth = closing.bracket_depth + 1 + # Locate `opening` by scanning inward from both ends at once. Callers pass the + # whole line's leaf list and this runs once per bracket, so a plain forward scan + # from the start costs O(index) and turns quadratic on a long line; meeting in + # the middle bounds each lookup to the nearer end. + _opening_index = -1 + left = 0 + right = len(leaves) - 1 + while left <= right: + if leaves[left] is opening: + _opening_index = left + break + if leaves[right] is opening: + _opening_index = right + break + left += 1 + right -= 1 + + if _opening_index == -1: + return False + + commas = 0 + _opening_index += 1 + for leaf in leaves[_opening_index:]: + if leaf is closing: + break + + bracket_depth = leaf.bracket_depth + if bracket_depth == depth and leaf.type == token.COMMA: + commas += 1 + if leaf.parent and leaf.parent.type in { + syms.arglist, + syms.typedargslist, + }: + commas += 1 + break + + return commas < 2 + + +def is_walrus_assignment(node: LN) -> bool: + """Return True iff `node` is of the shape ( test := test )""" + inner = unwrap_singleton_parenthesis(node) + return inner is not None and inner.type == syms.namedexpr_test + + +def is_simple_decorator_trailer(node: LN, last: bool = False) -> bool: + """Return True iff `node` is a trailer valid in a simple decorator""" + return node.type == syms.trailer and ( + ( + len(node.children) == 2 + and node.children[0].type == token.DOT + and node.children[1].type == token.NAME + ) + # last trailer can be an argument-less parentheses pair + or ( + last + and len(node.children) == 2 + and node.children[0].type == token.LPAR + and node.children[1].type == token.RPAR + ) + # last trailer can be arguments + or ( + last + and len(node.children) == 3 + and node.children[0].type == token.LPAR + # and node.children[1].type == syms.argument + and node.children[2].type == token.RPAR + ) + ) + + +def is_simple_decorator_expression(node: LN) -> bool: + """Return True iff `node` could be a 'dotted name' decorator + + This function takes the node of the 'namedexpr_test' of the new decorator + grammar and test if it would be valid under the old decorator grammar. + + The old grammar was: decorator: @ dotted_name [arguments] NEWLINE + The new grammar is : decorator: @ namedexpr_test NEWLINE + """ + if node.type == token.NAME: + return True + if node.type == syms.power: + if node.children: + return ( + node.children[0].type == token.NAME + and all(map(is_simple_decorator_trailer, node.children[1:-1])) + and ( + len(node.children) < 2 + or is_simple_decorator_trailer(node.children[-1], last=True) + ) + ) + return False + + +def is_yield(node: LN) -> bool: + """Return True if `node` holds a `yield` or `yield from` expression.""" + if node.type == syms.yield_expr: + return True + + if is_name_token(node) and node.value == "yield": + return True + + if node.type != syms.atom: + return False + + if len(node.children) != 3: + return False + + lpar, expr, rpar = node.children + if lpar.type == token.LPAR and rpar.type == token.RPAR: + return is_yield(expr) + + return False + + +def is_vararg(leaf: Leaf, within: set[NodeType]) -> bool: + """Return True if `leaf` is a star or double star in a vararg or kwarg. + + If `within` includes VARARGS_PARENTS, this applies to function signatures. + If `within` includes UNPACKING_PARENTS, it applies to right hand-side + extended iterable unpacking (PEP 3132) and additional unpacking + generalizations (PEP 448). + """ + if leaf.type not in VARARGS_SPECIALS or not leaf.parent: + return False + + p = leaf.parent + if p.type == syms.star_expr: + # Star expressions are also used as assignment targets in extended + # iterable unpacking (PEP 3132). See what its parent is instead. + if not p.parent: + return False + + p = p.parent + + return p.type in within + + +def is_fstring(node: Node) -> bool: + """Return True if the node is an f-string""" + return node.type == syms.fstring + + +def fstring_tstring_to_string(node: Node) -> Leaf: + """Converts an fstring or tstring node back to a string node.""" + string_without_prefix = str(node)[len(node.prefix) :] + string_leaf = Leaf(token.STRING, string_without_prefix, prefix=node.prefix) + string_leaf.lineno = node.get_lineno() or 0 + return string_leaf + + +def is_multiline_string(node: LN) -> bool: + """Return True if `leaf` is a multiline string that actually spans many lines.""" + if isinstance(node, Node) and is_fstring(node): + leaf = fstring_tstring_to_string(node) + elif isinstance(node, Leaf): + leaf = node + else: + return False + + return has_triple_quotes(leaf.value) and "\n" in leaf.value + + +def is_parent_function_or_class(node: Node) -> bool: + assert node.type in {syms.suite, syms.simple_stmt} + assert node.parent is not None + # Note this works for suites / simple_stmts in async def as well + return node.parent.type in {syms.funcdef, syms.classdef} + + +def is_stub_suite(node: Node) -> bool: + """Return True if `node` is a suite with a stub body.""" + if node.parent is not None and not is_parent_function_or_class(node): + return False + + # If there is a comment, we want to keep it. + if node.prefix.strip(): + return False + + if ( + len(node.children) != 4 + or node.children[0].type != token.NEWLINE + or node.children[1].type != token.INDENT + or node.children[3].type != token.DEDENT + ): + return False + + if node.children[3].prefix.strip(): + return False + + return is_stub_body(node.children[2]) + + +def is_stub_body(node: LN) -> bool: + """Return True if `node` is a simple statement containing an ellipsis.""" + if not isinstance(node, Node) or node.type != syms.simple_stmt: + return False + + if len(node.children) != 2: + return False + + child = node.children[0] + return ( + not child.prefix.strip() + and child.type == syms.atom + and len(child.children) == 3 + and all(leaf == Leaf(token.DOT, ".") for leaf in child.children) + ) + + +def is_atom_with_invisible_parens(node: LN) -> bool: + """Given a `LN`, determines whether it's an atom `node` with invisible + parens. Useful in dedupe-ing and normalizing parens. + """ + if isinstance(node, Leaf) or node.type != syms.atom: + return False + + first, last = node.children[0], node.children[-1] + return ( + isinstance(first, Leaf) + and first.type == token.LPAR + and first.value == "" + and isinstance(last, Leaf) + and last.type == token.RPAR + and last.value == "" + ) + + +def is_empty_par(leaf: Leaf) -> bool: + return is_empty_lpar(leaf) or is_empty_rpar(leaf) + + +def is_empty_lpar(leaf: Leaf) -> bool: + return leaf.type == token.LPAR and leaf.value == "" + + +def is_empty_rpar(leaf: Leaf) -> bool: + return leaf.type == token.RPAR and leaf.value == "" + + +def is_import(leaf: Leaf) -> bool: + """Return True if the given leaf starts an import statement.""" + p = leaf.parent + t = leaf.type + v = leaf.value + return bool( + (t == token.LAZY and p and p.type == syms.lazy_import) + or ( + t == token.NAME + and ( + (v == "import" and p and p.type == syms.import_name) + or (v == "from" and p and p.type == syms.import_from) + ) + ) + ) + + +def is_with_or_async_with_stmt(leaf: Leaf) -> bool: + """Return True if the given leaf starts a with or async with statement.""" + return bool( + leaf.type == token.NAME + and leaf.value == "with" + and leaf.parent + and leaf.parent.type == syms.with_stmt + ) or bool( + leaf.type == token.ASYNC + and leaf.next_sibling + and leaf.next_sibling.type == syms.with_stmt + ) + + +def is_async_stmt_or_funcdef(leaf: Leaf) -> bool: + """Return True if the given leaf starts an async def/for/with statement. + + Note that `async def` can be either an `async_stmt` or `async_funcdef`, + the latter is used when it has decorators. + """ + return bool( + leaf.type == token.ASYNC + and leaf.parent + and leaf.parent.type in {syms.async_stmt, syms.async_funcdef} + ) + + +def is_type_comment(leaf: Leaf, mode: Mode) -> bool: + """Return True if the given leaf is a type comment. This function should only + be used for general type comments (excluding ignore annotations, which should + use `is_type_ignore_comment`). Note that general type comments are no longer + used in modern version of Python, this function may be deprecated in the future.""" + t = leaf.type + v = leaf.value + return t in {token.COMMENT, STANDALONE_COMMENT} and is_type_comment_string(v, mode) + + +def is_type_comment_string(value: str, mode: Mode) -> bool: + return value.startswith("#") and value[1:].lstrip().startswith("type:") + + +def is_type_ignore_comment(leaf: Leaf, mode: Mode) -> bool: + """Return True if the given leaf is a type comment with ignore annotation.""" + t = leaf.type + v = leaf.value + return t in {token.COMMENT, STANDALONE_COMMENT} and is_type_ignore_comment_string( + v, mode + ) + + +def is_type_ignore_comment_string(value: str, mode: Mode) -> bool: + """Return True if the given string match with type comment with + ignore annotation.""" + return is_type_comment_string(value, mode) and value.split(":", 1)[ + 1 + ].lstrip().startswith("ignore") + + +def wrap_in_parentheses( + parent: Node, child: LN, *, visible: bool = True, index: int | None = None +) -> None: + """Wrap `child` in parentheses. + + This replaces `child` with an atom holding the parentheses and the old + child. That requires moving the prefix. + + If `visible` is False, the leaves will be valueless (and thus invisible). + + When the caller already knows `child`'s position in `parent.children` it + can pass `index` so the child is swapped in place. The default path locates + `child` with `Base.remove`, which scans and rewrites the whole child list; + that is O(len(parent.children)) per call and turns quadratic when a caller + wraps every child of a large node (e.g. each value of a big dict literal). + """ + lpar = Leaf(token.LPAR, "(" if visible else "") + rpar = Leaf(token.RPAR, ")" if visible else "") + prefix = child.prefix + child.prefix = "" + if index is None: + index = child.remove() or 0 + new_child = Node(syms.atom, [lpar, child, rpar]) + new_child.prefix = prefix + parent.insert_child(index, new_child) + else: + # Detach the child pointer first so the atom can adopt it, then swap it + # in place. set_child resets the old child's parent, so reattach it to + # the new atom afterwards. + child.parent = None + new_child = Node(syms.atom, [lpar, child, rpar]) + new_child.prefix = prefix + parent.set_child(index, new_child) + child.parent = new_child + + +def unwrap_singleton_parenthesis(node: LN) -> LN | None: + """Returns `wrapped` if `node` is of the shape ( wrapped ). + + Parenthesis can be optional. Returns None otherwise""" + if len(node.children) != 3: + return None + + lpar, wrapped, rpar = node.children + if not (lpar.type == token.LPAR and rpar.type == token.RPAR): + return None + + return wrapped + + +def ensure_visible(leaf: Leaf) -> None: + """Make sure parentheses are visible. + + They could be invisible as part of some statements (see + :func:`normalize_invisible_parens` and :func:`visit_import_from`). + """ + if leaf.type == token.LPAR: + leaf.value = "(" + elif leaf.type == token.RPAR: + leaf.value = ")" + + +def is_name_token(nl: NL) -> TypeGuard[Leaf]: + return nl.type == token.NAME + + +def is_lpar_token(nl: NL) -> TypeGuard[Leaf]: + return nl.type == token.LPAR + + +def is_rpar_token(nl: NL) -> TypeGuard[Leaf]: + return nl.type == token.RPAR + + +def is_number_token(nl: NL) -> TypeGuard[Leaf]: + return nl.type == token.NUMBER + + +def get_annotation_type(leaf: Leaf) -> Literal["return", "param", None]: + """Returns the type of annotation this leaf is part of, if any.""" + ancestor = leaf.parent + while ancestor is not None: + if ancestor.prev_sibling and ancestor.prev_sibling.type == token.RARROW: + return "return" + if ancestor.parent and ancestor.parent.type == syms.tname: + return "param" + ancestor = ancestor.parent + return None + + +def is_part_of_annotation(leaf: Leaf) -> bool: + """Returns whether this leaf is part of a type annotation.""" + assert leaf.parent is not None + return get_annotation_type(leaf) is not None + + +def first_leaf(node: LN) -> Leaf | None: + """Returns the first leaf of the ancestor node.""" + if isinstance(node, Leaf): + return node + elif not node.children: + return None + else: + return first_leaf(node.children[0]) + + +def last_leaf(node: LN) -> Leaf | None: + """Returns the last leaf of the ancestor node.""" + if isinstance(node, Leaf): + return node + elif not node.children: + return None + else: + return last_leaf(node.children[-1]) + + +def furthest_ancestor_with_last_leaf(leaf: Leaf) -> LN: + """Returns the furthest ancestor that has this leaf node as the last leaf.""" + node: LN = leaf + while node.parent and node.parent.children and node is node.parent.children[-1]: + node = node.parent + return node + + +def has_sibling_with_type(node: LN, type: int) -> bool: + # Check previous siblings + sibling = node.prev_sibling + while sibling is not None: + if sibling.type == type: + return True + sibling = sibling.prev_sibling + + # Check next siblings + sibling = node.next_sibling + while sibling is not None: + if sibling.type == type: + return True + sibling = sibling.next_sibling + + return False diff --git a/src/black/numerics.py b/src/black/numerics.py new file mode 100644 index 0000000..3040de0 --- /dev/null +++ b/src/black/numerics.py @@ -0,0 +1,61 @@ +""" +Formatting numeric literals. +""" + +from blib2to3.pytree import Leaf + + +def format_hex(text: str) -> str: + """ + Formats a hexadecimal string like "0x12B3" + """ + before, after = text[:2], text[2:] + return f"{before}{after.upper()}" + + +def format_scientific_notation(text: str) -> str: + """Formats a numeric string utilizing scientific notation""" + before, after = text.split("e") + sign = "" + if after.startswith("-"): + after = after[1:] + sign = "-" + elif after.startswith("+"): + after = after[1:] + before = format_float_or_int_string(before) + return f"{before}e{sign}{after}" + + +def format_complex_number(text: str) -> str: + """Formats a complex string like `10j`""" + number = text[:-1] + suffix = text[-1] + return f"{format_float_or_int_string(number)}{suffix}" + + +def format_float_or_int_string(text: str) -> str: + """Formats a float string like "1.0".""" + if "." not in text: + return text + + before, after = text.split(".") + return f"{before or 0}.{after or 0}" + + +def normalize_numeric_literal(leaf: Leaf) -> None: + """Normalizes numeric (float, int, and complex) literals. + + All letters used in the representation are normalized to lowercase.""" + text = leaf.value.lower() + if text.startswith(("0o", "0b")): + # Leave octal and binary literals alone. + pass + elif text.startswith("0x"): + text = format_hex(text) + elif "e" in text: + text = format_scientific_notation(text) + elif text.endswith("j"): + text = format_complex_number(text) + else: + text = format_float_or_int_string(text) + leaf.value = text diff --git a/src/black/output.py b/src/black/output.py new file mode 100644 index 0000000..61d712e --- /dev/null +++ b/src/black/output.py @@ -0,0 +1,135 @@ +"""Nice output for Black. + +The double calls are for patching purposes in tests. +""" + +import json +import os +import re +import tempfile +from typing import Any + +from click import echo, style +from mypy_extensions import mypyc_attr + + +@mypyc_attr(patchable=True) +def _out(message: str | None = None, nl: bool = True, **styles: Any) -> None: + if message is not None: + if "bold" not in styles: + styles["bold"] = True + message = style_output(message, **styles) + echo(message, nl=nl, err=True) + + +@mypyc_attr(patchable=True) +def _err(message: str | None = None, nl: bool = True, **styles: Any) -> None: + if message is not None: + if "fg" not in styles: + styles["fg"] = "red" + message = style_output(message, **styles) + echo(message, nl=nl, err=True) + + +@mypyc_attr(patchable=True) +def out(message: str | None = None, nl: bool = True, **styles: Any) -> None: + _out(message, nl=nl, **styles) + + +def err(message: str | None = None, nl: bool = True, **styles: Any) -> None: + _err(message, nl=nl, **styles) + + +def ipynb_diff(a: str, b: str, a_name: str, b_name: str) -> str: + """Return a unified diff string between each cell in notebooks `a` and `b`.""" + a_nb = json.loads(a) + b_nb = json.loads(b) + diff_lines = [ + diff( + "".join(a_nb["cells"][cell_number]["source"]) + "\n", + "".join(b_nb["cells"][cell_number]["source"]) + "\n", + f"{a_name}:cell_{cell_number}", + f"{b_name}:cell_{cell_number}", + ) + for cell_number, cell in enumerate(a_nb["cells"]) + if cell["cell_type"] == "code" + ] + return "".join(diff_lines) + + +_line_pattern = re.compile(r"(.*?(?:\r\n|\n|\r|$))") + + +def _splitlines_no_ff(source: str) -> list[str]: + """Split a string into lines ignoring form feed and other chars. + + This mimics how the Python parser splits source code. + + A simplified version of the function with the same name in Lib/ast.py + """ + result = [match[0] for match in _line_pattern.finditer(source)] + if result[-1] == "": + result.pop(-1) + return result + + +def diff(a: str, b: str, a_name: str, b_name: str) -> str: + """Return a unified diff string between strings `a` and `b`.""" + import difflib + + a_lines = _splitlines_no_ff(a) + b_lines = _splitlines_no_ff(b) + diff_lines = [] + for line in difflib.unified_diff( + a_lines, b_lines, fromfile=a_name, tofile=b_name, n=5 + ): + # Work around https://bugs.python.org/issue2142 + # See: + # https://www.gnu.org/software/diffutils/manual/html_node/Incomplete-Lines.html + if line[-1] == "\n": + diff_lines.append(line) + else: + diff_lines.append(line + "\n") + diff_lines.append("\\ No newline at end of file\n") + return "".join(diff_lines) + + +def color_diff(contents: str) -> str: + """Inject the ANSI color codes to the diff.""" + if not _color_enabled(): + return contents + lines = contents.split("\n") + for i, line in enumerate(lines): + if line.startswith("+++") or line.startswith("---"): + line = "\033[1m" + line + "\033[0m" # bold, reset + elif line.startswith("@@"): + line = "\033[36m" + line + "\033[0m" # cyan, reset + elif line.startswith("+"): + line = "\033[32m" + line + "\033[0m" # green, reset + elif line.startswith("-"): + line = "\033[31m" + line + "\033[0m" # red, reset + lines[i] = line + return "\n".join(lines) + + +def style_output(message: str, **styles: Any) -> str: + if not _color_enabled(): + return message + return style(message, **styles) + + +def _color_enabled() -> bool: + return "NO_COLOR" not in os.environ + + +@mypyc_attr(patchable=True) +def dump_to_file(*output: str, ensure_final_newline: bool = True) -> str: + """Dump `output` to a temporary file. Return path to the file.""" + with tempfile.NamedTemporaryFile( + mode="w", prefix="blk_", suffix=".log", delete=False, encoding="utf8" + ) as f: + for lines in output: + f.write(lines) + if ensure_final_newline and lines and lines[-1] != "\n": + f.write("\n") + return f.name diff --git a/src/black/parsing.py b/src/black/parsing.py new file mode 100644 index 0000000..bdf95d8 --- /dev/null +++ b/src/black/parsing.py @@ -0,0 +1,266 @@ +""" +Parse Python code and perform AST validation. +""" + +import ast +import sys +import warnings +from collections.abc import Collection, Iterator + +from black.mode import VERSION_TO_FEATURES, Feature, TargetVersion, supports_feature +from black.nodes import syms +from blib2to3 import pygram +from blib2to3.pgen2 import driver +from blib2to3.pgen2.grammar import Grammar +from blib2to3.pgen2.parse import ParseError +from blib2to3.pgen2.tokenize import TokenError +from blib2to3.pytree import Leaf, Node + + +class InvalidInput(ValueError): + """Raised when input source code fails all parse attempts.""" + + +def get_grammars(target_versions: set[TargetVersion]) -> list[Grammar]: + if not target_versions: + # No target_version specified, so try all grammars. + return [ + # Python 3.7-3.9 + pygram.python_grammar_async_keywords, + # Python 3.0-3.6 + pygram.python_grammar, + # Python 3.10+ + pygram.python_grammar_soft_keywords, + ] + + grammars = [] + # If we have to parse both, try to parse async as a keyword first + if not supports_feature( + target_versions, Feature.ASYNC_IDENTIFIERS + ) and not supports_feature(target_versions, Feature.PATTERN_MATCHING): + # Python 3.7-3.9 + grammars.append(pygram.python_grammar_async_keywords) + if not supports_feature(target_versions, Feature.ASYNC_KEYWORDS): + # Python 3.0-3.6 + grammars.append(pygram.python_grammar) + if any(Feature.PATTERN_MATCHING in VERSION_TO_FEATURES[v] for v in target_versions): + # Python 3.10+ + grammars.append(pygram.python_grammar_soft_keywords) + + # At least one of the above branches must have been taken, because every Python + # version has exactly one of the two 'ASYNC_*' flags + return grammars + + +def lib2to3_parse( + src_txt: str, target_versions: Collection[TargetVersion] = () +) -> Node: + """Given a string with source, return the lib2to3 Node.""" + if not src_txt.endswith("\n"): + src_txt += "\n" + + grammars = get_grammars(set(target_versions)) + if target_versions: + max_tv = max(target_versions, key=lambda tv: tv.value) + tv_str = f" for target version {max_tv.pretty()}" + else: + tv_str = "" + + errors = {} + for grammar in grammars: + drv = driver.Driver(grammar) + try: + result = drv.parse_string(src_txt, False) + break + + except ParseError as pe: + lineno, column = pe.context[1] + lines = src_txt.splitlines() + try: + faulty_line = lines[lineno - 1] + except IndexError: + faulty_line = "" + error_msg = ( + f"Cannot parse{tv_str}: {lineno}:{column}\n" + f" {faulty_line}\n" + f" {' ' * (column - 1)}^\n" + f"ParseError: {pe.msg}" + ) + + errors[grammar.version] = InvalidInput(error_msg) + + except TokenError as te: + lineno, column = te.args[1] + lines = src_txt.splitlines() + try: + faulty_line = lines[lineno - 1] + except IndexError: + faulty_line = "" + error_msg = ( + f"Cannot parse{tv_str}: {lineno}:{column}\n" + f" {faulty_line}\n" + f" {' ' * (column - 1)}^\n" + f"TokenError: {te.args[0]}" + ) + errors[grammar.version] = InvalidInput(error_msg) + + else: + # Choose the latest version when raising the actual parsing error. + assert len(errors) >= 1 + exc = errors[max(errors)] + raise exc from None + + if isinstance(result, Leaf): + result = Node(syms.file_input, [result]) + return result + + +class ASTSafetyError(Exception): + """Raised when Black's generated code is not equivalent to the old AST.""" + + +class SourceASTParseError(Exception): + """Raised when the source file cannot be parsed by ast.parse(). + + This is not a bug in Black — Black's lib2to3-based parser is more lenient + than Python's ast.parse(), so it may accept code that ast.parse() rejects. + In blackd, this should be reported as a 400 Bad Request. + """ + + +def _parse_single_version( + src: str, version: tuple[int, int], *, type_comments: bool +) -> ast.AST: + filename = "" + with warnings.catch_warnings(): + warnings.simplefilter("ignore", SyntaxWarning) + warnings.simplefilter("ignore", DeprecationWarning) + return ast.parse( + src, filename, feature_version=version, type_comments=type_comments + ) + + +def parse_ast(src: str) -> ast.AST: + # TODO: support Python 4+ ;) + versions = [(3, minor) for minor in range(3, sys.version_info[1] + 1)] + + first_error = "" + for version in sorted(versions, reverse=True): + try: + return _parse_single_version(src, version, type_comments=True) + except SyntaxError as e: + if not first_error: + first_error = str(e) + + # Try to parse without type comments + for version in sorted(versions, reverse=True): + try: + return _parse_single_version(src, version, type_comments=False) + except SyntaxError: + pass + + raise SyntaxError(first_error) + + +def _normalize(lineend: str, value: str) -> str: + # To normalize, we strip any leading and trailing space from + # each line... + stripped: list[str] = [i.strip() for i in value.splitlines()] + normalized = lineend.join(stripped) + # ...and remove any blank lines at the beginning and end of + # the whole string + return normalized.strip() + + +def stringify_ast(node: ast.AST) -> Iterator[str]: + """Simple visitor generating strings to compare ASTs by content.""" + return _stringify_ast(node, []) + + +def _stringify_ast_with_new_parent( + node: ast.AST, parent_stack: list[ast.AST], new_parent: ast.AST +) -> Iterator[str]: + parent_stack.append(new_parent) + yield from _stringify_ast(node, parent_stack) + parent_stack.pop() + + +def _stringify_ast(node: ast.AST, parent_stack: list[ast.AST]) -> Iterator[str]: + if ( + isinstance(node, ast.Constant) + and isinstance(node.value, str) + and node.kind == "u" + ): + # It's a quirk of history that we strip the u prefix over here. We used to + # rewrite the AST nodes for Python version compatibility and we never copied + # over the kind + node.kind = None + + yield f"{' ' * len(parent_stack)}{node.__class__.__name__}(" + + for field in sorted(node._fields): + # TypeIgnore has only one field 'lineno' which breaks this comparison + if isinstance(node, ast.TypeIgnore): + break + + try: + value: object = getattr(node, field) + except AttributeError: + continue + + yield f"{' ' * (len(parent_stack) + 1)}{field}=" + + if isinstance(value, list): + for item in value: + # Ignore nested tuples within del statements, because we may insert + # parentheses and they change the AST. + if ( + field == "targets" + and isinstance(node, ast.Delete) + and isinstance(item, ast.Tuple) + ): + for elt in _unwrap_tuples(item): + yield from _stringify_ast_with_new_parent( + elt, parent_stack, node + ) + + elif isinstance(item, ast.AST): + yield from _stringify_ast_with_new_parent(item, parent_stack, node) + + elif isinstance(value, ast.AST): + yield from _stringify_ast_with_new_parent(value, parent_stack, node) + + else: + normalized: object + if ( + isinstance(node, ast.Constant) + and field == "value" + and isinstance(value, str) + and len(parent_stack) >= 2 + # Any standalone string, ideally this would + # exactly match black.nodes.is_docstring + and isinstance(parent_stack[-1], ast.Expr) + ): + # Constant strings may be indented across newlines, if they are + # docstrings; fold spaces after newlines when comparing. Similarly, + # trailing and leading space may be removed. + normalized = _normalize("\n", value) + elif field == "type_comment" and isinstance(value, str): + # Trailing whitespace in type comments is removed. + normalized = value.rstrip() + else: + normalized = value + yield ( + f"{' ' * (len(parent_stack) + 1)}{normalized!r}, #" + f" {value.__class__.__name__}" + ) + + yield f"{' ' * len(parent_stack)}) # /{node.__class__.__name__}" + + +def _unwrap_tuples(node: ast.Tuple) -> Iterator[ast.AST]: + for elt in node.elts: + if isinstance(elt, ast.Tuple): + yield from _unwrap_tuples(elt) + else: + yield elt diff --git a/src/black/py.typed b/src/black/py.typed new file mode 100644 index 0000000..e69de29 diff --git a/src/black/ranges.py b/src/black/ranges.py new file mode 100644 index 0000000..16db00b --- /dev/null +++ b/src/black/ranges.py @@ -0,0 +1,637 @@ +"""Functions related to Black's formatting by line ranges feature.""" + +import difflib +from collections.abc import Collection, Iterator, Sequence +from dataclasses import dataclass + +from black.nodes import ( + LN, + STANDALONE_COMMENT, + Leaf, + Node, + Visitor, + first_leaf, + furthest_ancestor_with_last_leaf, + last_leaf, + syms, +) +from blib2to3.pgen2.token import ASYNC, NEWLINE + + +def parse_line_ranges(line_ranges: Sequence[str]) -> list[tuple[int, int]]: + lines: list[tuple[int, int]] = [] + for lines_str in line_ranges: + parts = lines_str.split("-") + if len(parts) != 2: + raise ValueError( + "Incorrect --line-ranges format, expect 'START-END', found" + f" {lines_str!r}" + ) + try: + start = int(parts[0]) + end = int(parts[1]) + except ValueError: + raise ValueError( + "Incorrect --line-ranges value, expect integer ranges, found" + f" {lines_str!r}" + ) from None + else: + if start < 1 or end < 1: + raise ValueError( + "Incorrect --line-ranges value, " + f"expect positive integers, found {lines_str!r}" + ) + if start > end: + raise ValueError( + "Incorrect --line-ranges value, expect START <= END, " + f"found {lines_str!r}" + ) + lines.append((start, end)) + return lines + + +def is_valid_line_range(lines: tuple[int, int]) -> bool: + """Returns whether the line range is valid.""" + return not lines or lines[0] <= lines[1] + + +def sanitized_lines( + lines: Collection[tuple[int, int]], src_contents: str +) -> Collection[tuple[int, int]]: + """Returns the valid line ranges for the given source. + + This removes ranges that are entirely outside the valid lines. + + Other ranges are normalized so that the start values are at least 1 and the + end values are at most the (1-based) index of the last source line. + """ + if not src_contents: + return [] + good_lines = [] + src_line_count = src_contents.count("\n") + if not src_contents.endswith("\n"): + src_line_count += 1 + for start, end in lines: + if start > src_line_count: + continue + # line-ranges are 1-based + start = max(start, 1) + if end < start: + continue + end = min(end, src_line_count) + good_lines.append((start, end)) + return good_lines + + +def adjusted_lines( + lines: Collection[tuple[int, int]], + original_source: str, + modified_source: str, +) -> list[tuple[int, int]]: + """Returns the adjusted line ranges based on edits from the original code. + + This computes the new line ranges by diffing original_source and + modified_source, and adjust each range based on how the range overlaps with + the diffs. + + Note the diff can contain lines outside of the original line ranges. This can + happen when the formatting has to be done in adjacent to maintain consistent + local results. For example: + + 1. def my_func(arg1, arg2, + 2. arg3,): + 3. pass + + If it restricts to line 2-2, it can't simply reformat line 2, it also has + to reformat line 1: + + 1. def my_func( + 2. arg1, + 3. arg2, + 4. arg3, + 5. ): + 6. pass + + In this case, we will expand the line ranges to also include the whole diff + block. + + Args: + lines: a collection of line ranges. + original_source: the original source. + modified_source: the modified source. + """ + lines_mappings = _calculate_lines_mappings(original_source, modified_source) + + new_lines = [] + # Keep an index of the current search. Since the lines and lines_mappings are + # sorted, this makes the search complexity linear. + current_mapping_index = 0 + for start, end in sorted(lines): + start_mapping_index = _find_lines_mapping_index( + start, + lines_mappings, + current_mapping_index, + ) + end_mapping_index = _find_lines_mapping_index( + end, + lines_mappings, + start_mapping_index, + ) + current_mapping_index = start_mapping_index + if start_mapping_index >= len(lines_mappings) or end_mapping_index >= len( + lines_mappings + ): + # Protect against invalid inputs. + continue + start_mapping = lines_mappings[start_mapping_index] + end_mapping = lines_mappings[end_mapping_index] + if start_mapping.is_changed_block: + # When the line falls into a changed block, expands to the whole block. + new_start = start_mapping.modified_start + else: + new_start = ( + start - start_mapping.original_start + start_mapping.modified_start + ) + if end_mapping.is_changed_block: + # When the line falls into a changed block, expands to the whole block. + new_end = end_mapping.modified_end + else: + new_end = end - end_mapping.original_start + end_mapping.modified_start + new_range = (new_start, new_end) + if is_valid_line_range(new_range): + new_lines.append(new_range) + return new_lines + + +def convert_unchanged_lines(src_node: Node, lines: Collection[tuple[int, int]]) -> None: + r"""Converts unchanged lines to STANDALONE_COMMENT. + + The idea is similar to how `# fmt: on/off` is implemented. It also converts the + nodes between those markers as a single `STANDALONE_COMMENT` leaf node with + the unformatted code as its value. `STANDALONE_COMMENT` is a "fake" token + that will be formatted as-is with its prefix normalized. + + Here we perform two passes: + + 1. Visit the top-level statements, and convert them to a single + `STANDALONE_COMMENT` when unchanged. This speeds up formatting when some + of the top-level statements aren't changed. + 2. Convert unchanged "unwrapped lines" to `STANDALONE_COMMENT` nodes line by + line. "unwrapped lines" are divided by the `NEWLINE` token. e.g. a + multi-line statement is *one* "unwrapped line" that ends with `NEWLINE`, + even though this statement itself can span multiple lines, and the + tokenizer only sees the last '\n' as the `NEWLINE` token. + + NOTE: During pass (2), comment prefixes and indentations are ALWAYS + normalized even when the lines aren't changed. This is fixable by moving + more formatting to pass (1). However, it's hard to get it correct when + incorrect indentations are used. So we defer this to future optimizations. + """ + lines_set: set[int] = set() + for start, end in lines: + lines_set.update(range(start, end + 1)) + replacements = _NodeReplacements() + visitor = _TopLevelStatementsVisitor(lines_set, replacements) + _ = list(visitor.visit(src_node)) # Consume all results. + replacements.apply() + _convert_unchanged_line_by_line(src_node, lines_set) + + +class _NodeReplacements: + """Collects STANDALONE_COMMENT conversions and applies them per parent. + + Converting a node splices a `STANDALONE_COMMENT` leaf in place of a run of + sibling nodes. Doing that one node at a time with `Base.remove` / + `insert_child` scans and shifts the parent's children list on every call, so + converting the many sibling blocks of one parent (a long if/elif chain, a + match with many cases, a module with many top-level statements) is O(n^2). + Recording the conversions and rewriting each parent's children in a single + pass makes it O(n). + """ + + def __init__(self) -> None: + # id(parent) -> (parent, {id(child): standalone to splice in}, {ids to drop}) + # A run's nodes can live under more than one parent (an `async` statement + # keeps the `ASYNC` leaf on the grandparent), so the standalone replaces + # the run's first node under its own parent while the remaining nodes are + # just dropped from wherever they sit. + self._by_parent: dict[int, tuple[Node, dict[int, Leaf], set[int]]] = {} + # NEWLINE leaves already inside a recorded run, so the line-by-line pass + # doesn't record an overlapping conversion for them. + self.covered_newlines: set[int] = set() + # Nodes already scheduled for removal. When conversions immediately + # mutated the tree, a second conversion touching an already-removed node + # was a no-op (`Base.remove` returned None); recording defers the + # mutation, so we skip such nodes explicitly to keep that behaviour. + self._recorded: set[int] = set() + # A leaf's prefix (indentation, blank lines, comments) moves onto its + # STANDALONE_COMMENT. When an inner and an outer node that share the same + # first leaf are both converted (a decorator inside a decorated block), + # the earlier conversion clears the prefix off the leaf, so the later one + # would see an empty prefix. Remember the taken prefix keyed by the leaf + # so both conversions reuse the original. + self._taken_prefixes: dict[int, str] = {} + + def _entry(self, parent: Node) -> tuple[Node, dict[int, Leaf], set[int]]: + return self._by_parent.setdefault(id(parent), (parent, {}, set())) + + def take_prefix(self, first: Leaf) -> str: + cached = self._taken_prefixes.get(id(first)) + if cached is not None: + return cached + prefix = first.prefix + first.prefix = "" + # Immediate conversion replaced the whole run with a freshly built + # STANDALONE_COMMENT leaf, whose synthesized position is line 0. Recording + # the conversion leaves the original leaf in place, so mirror that line 0 + # here: when a later, enclosing node shares this first leaf (a decorated + # block over an already-recorded decorator), _get_line_range sees the run + # as starting at line 0, matching the immediate behaviour. + first.lineno = 0 + self._taken_prefixes[id(first)] = prefix + return prefix + + def is_recorded(self, node: LN) -> bool: + return id(node) in self._recorded + + def record(self, run: list[LN], standalone: Leaf) -> None: + first = run[0] + first_parent = first.parent + if first_parent is None or id(first) in self._recorded: + return + for node in run: + self._recorded.add(id(node)) + for leaf in node.leaves(): + if leaf.type == NEWLINE: + self.covered_newlines.add(id(leaf)) + parent = node.parent + if parent is not None: + self._entry(parent)[2].add(id(node)) + self._entry(first_parent)[1][id(first)] = standalone + + def apply(self) -> None: + for parent, replaced, removed in self._by_parent.values(): + new_children: list[LN] = [] + for child in parent.children: + standalone = replaced.get(id(child)) + if standalone is not None: + standalone.parent = parent + new_children.append(standalone) + child.parent = None + elif id(child) in removed: + child.parent = None + else: + new_children.append(child) + parent.children = new_children + parent.changed() + parent.invalidate_sibling_maps() + + +def _contains_standalone_comment(node: LN) -> bool: + if isinstance(node, Leaf): + return node.type == STANDALONE_COMMENT + else: + for child in node.children: + if _contains_standalone_comment(child): + return True + return False + + +class _TopLevelStatementsVisitor(Visitor[None]): + """ + A node visitor that converts unchanged top-level statements to + STANDALONE_COMMENT. + + This is used in addition to _convert_unchanged_line_by_line, to + speed up formatting when there are unchanged top-level + classes/functions/statements. + """ + + def __init__(self, lines_set: set[int], replacements: "_NodeReplacements"): + self._lines_set = lines_set + self._replacements = replacements + + def visit_simple_stmt(self, node: Node) -> Iterator[None]: + # This is only called for top-level statements, since `visit_suite` + # won't visit its children nodes. + yield from [] + newline_leaf = last_leaf(node) + if not newline_leaf: + return + assert ( + newline_leaf.type == NEWLINE + ), f"Unexpectedly found leaf.type={newline_leaf.type}" + # We need to find the furthest ancestor with the NEWLINE as the last + # leaf, since a `suite` can simply be a `simple_stmt` when it puts + # its body on the same line. Example: `if cond: pass`. + ancestor = furthest_ancestor_with_last_leaf(newline_leaf) + if not _get_line_range(ancestor).intersection(self._lines_set): + _convert_node_to_standalone_comment(ancestor, self._replacements) + + def visit_suite(self, node: Node) -> Iterator[None]: + yield from [] + # If there is a STANDALONE_COMMENT node, it means parts of the node tree + # have fmt on/off/skip markers. Those STANDALONE_COMMENT nodes can't + # be simply converted by calling str(node). So we just don't convert + # here. + if _contains_standalone_comment(node): + return + # Find the semantic parent of this suite. For `async_stmt` and + # `async_funcdef`, the ASYNC token is defined on a separate level by the + # grammar. + semantic_parent = node.parent + if semantic_parent is not None: + if ( + semantic_parent.prev_sibling is not None + and semantic_parent.prev_sibling.type == ASYNC + ): + semantic_parent = semantic_parent.parent + if semantic_parent is not None and not _get_line_range( + semantic_parent + ).intersection(self._lines_set): + _convert_node_to_standalone_comment(semantic_parent, self._replacements) + + +def _convert_unchanged_line_by_line(node: Node, lines_set: set[int]) -> None: + """Converts unchanged to STANDALONE_COMMENT line by line.""" + replacements = _NodeReplacements() + for leaf in node.leaves(): + if leaf.type != NEWLINE: + # We only consider "unwrapped lines", which are divided by the NEWLINE + # token. + continue + if id(leaf) in replacements.covered_newlines: + # This NEWLINE is inside a run already scheduled for conversion (e.g. + # a second decorator on a stacked decorator block). + continue + if leaf.parent and leaf.parent.type == syms.match_stmt: + # The `suite` node is defined as: + # match_stmt: "match" subject_expr ':' NEWLINE INDENT case_block+ DEDENT + # Here we need to check `subject_expr`. The `case_block+` will be + # checked by their own NEWLINEs. + nodes_to_ignore: list[LN] = [] + prev_sibling = leaf.prev_sibling + while prev_sibling: + nodes_to_ignore.insert(0, prev_sibling) + prev_sibling = prev_sibling.prev_sibling + if not _get_line_range(nodes_to_ignore).intersection(lines_set): + _convert_nodes_to_standalone_comment( + nodes_to_ignore, newline=leaf, replacements=replacements + ) + elif leaf.parent and leaf.parent.type == syms.suite: + # The `suite` node is defined as: + # suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT + # We will check `simple_stmt` and `stmt+` separately against the lines set + parent_sibling = leaf.parent.prev_sibling + nodes_to_ignore = [] + while parent_sibling and parent_sibling.type != syms.suite: + # NOTE: Multiple suite nodes can exist as siblings in e.g. `if_stmt`. + nodes_to_ignore.insert(0, parent_sibling) + parent_sibling = parent_sibling.prev_sibling + # Special case for `async_stmt` and `async_funcdef` where the ASYNC + # token is on the grandparent node. + grandparent = leaf.parent.parent + if ( + grandparent is not None + and grandparent.prev_sibling is not None + and grandparent.prev_sibling.type == ASYNC + ): + nodes_to_ignore.insert(0, grandparent.prev_sibling) + if not _get_line_range(nodes_to_ignore).intersection(lines_set): + _convert_nodes_to_standalone_comment( + nodes_to_ignore, newline=leaf, replacements=replacements + ) + else: + ancestor = furthest_ancestor_with_last_leaf(leaf) + # Consider multiple decorators as a whole block, as their + # newlines have different behaviors than the rest of the grammar. + if ( + ancestor.type == syms.decorator + and ancestor.parent + and ancestor.parent.type == syms.decorators + ): + ancestor = ancestor.parent + if not _get_line_range(ancestor).intersection(lines_set): + _convert_node_to_standalone_comment(ancestor, replacements) + replacements.apply() + + +def _convert_node_to_standalone_comment( + node: LN, replacements: "_NodeReplacements" +) -> None: + """Convert node to STANDALONE_COMMENT by modifying the tree inline.""" + parent = node.parent + if not parent or replacements.is_recorded(node): + return + first = first_leaf(node) + last = last_leaf(node) + if not first or not last: + return + if first is last: + # This can happen on the following edge cases: + # 1. A block of `# fmt: off/on` code except the `# fmt: on` is placed + # on the end of the last line instead of on a new line. + # 2. A single backslash on its own line followed by a comment line. + # Ideally we don't want to format them when not requested, but fixing + # isn't easy. These cases are also badly formatted code, so it isn't + # too bad we reformat them. + return + # The prefix contains comments and indentation whitespaces. They are + # reformatted accordingly to the correct indentation level. + # This also means the indentation will be changed on the unchanged lines, and + # this is actually required to not break incremental reformatting. + prefix = replacements.take_prefix(first) + # For a single-line decorated item the decorator and the item need a newline + # between them. The conversions are recorded and applied in a single pass + # instead of mutating the tree per node, so the decorator here is still its + # own child node carrying its trailing NEWLINE, which already separates it + # from the item; there's nothing to add back. (A decorated item spanning + # multiple lines is handled by the earlier suite case in + # _convert_unchanged_line_by_line, which manages the newlines itself.) + # Remove the '\n', as STANDALONE_COMMENT will have '\n' appended when + # generating the formatted code. + value = str(node)[:-1] + replacements.record( + [node], + Leaf( + STANDALONE_COMMENT, + value, + prefix=prefix, + fmt_pass_converted_first_leaf=first, + ), + ) + + +def _convert_nodes_to_standalone_comment( + nodes: Sequence[LN], *, newline: Leaf, replacements: "_NodeReplacements" +) -> None: + """Convert nodes to STANDALONE_COMMENT by modifying the tree inline.""" + if not nodes: + return + parent = nodes[0].parent + first = first_leaf(nodes[0]) + if not parent or not first or replacements.is_recorded(nodes[0]): + return + prefix = replacements.take_prefix(first) + value = "".join(str(node) for node in nodes) + # The prefix comment on the NEWLINE leaf is the trailing comment of the statement. + if newline.prefix: + value += newline.prefix + newline.prefix = "" + replacements.record( + list(nodes), + Leaf( + STANDALONE_COMMENT, + value, + prefix=prefix, + fmt_pass_converted_first_leaf=first, + ), + ) + + +def _leaf_line_end(leaf: Leaf) -> int: + """Returns the line number of the leaf node's last line.""" + if leaf.type == NEWLINE: + return leaf.lineno + else: + # Leaf nodes like multiline strings can occupy multiple lines. + return leaf.lineno + str(leaf).count("\n") + + +def _get_line_range(node_or_nodes: LN | list[LN]) -> set[int]: + """Returns the line range of this node or list of nodes.""" + if isinstance(node_or_nodes, list): + nodes = node_or_nodes + if not nodes: + return set() + first = first_leaf(nodes[0]) + last = last_leaf(nodes[-1]) + if first and last: + line_start = first.lineno + line_end = _leaf_line_end(last) + return set(range(line_start, line_end + 1)) + else: + return set() + else: + node = node_or_nodes + if isinstance(node, Leaf): + return set(range(node.lineno, _leaf_line_end(node) + 1)) + else: + first = first_leaf(node) + last = last_leaf(node) + if first and last: + return set(range(first.lineno, _leaf_line_end(last) + 1)) + else: + return set() + + +@dataclass +class _LinesMapping: + """1-based lines mapping from original source to modified source. + + Lines [original_start, original_end] from original source + are mapped to [modified_start, modified_end]. + + The ranges are inclusive on both ends. + """ + + original_start: int + original_end: int + modified_start: int + modified_end: int + # Whether this range corresponds to a changed block, or an unchanged block. + is_changed_block: bool + + +def _calculate_lines_mappings( + original_source: str, + modified_source: str, +) -> Sequence[_LinesMapping]: + """Returns a sequence of _LinesMapping by diffing the sources. + + For example, given the following diff: + import re + - def func(arg1, + - arg2, arg3): + + def func(arg1, arg2, arg3): + pass + It returns the following mappings: + original -> modified + (1, 1) -> (1, 1), is_changed_block=False (the "import re" line) + (2, 3) -> (2, 2), is_changed_block=True (the diff) + (4, 4) -> (3, 3), is_changed_block=False (the "pass" line) + + You can think of this visually as if it brings up a side-by-side diff, and tries + to map the line ranges from the left side to the right side: + + (1, 1)->(1, 1) 1. import re 1. import re + (2, 3)->(2, 2) 2. def func(arg1, 2. def func(arg1, arg2, arg3): + 3. arg2, arg3): + (4, 4)->(3, 3) 4. pass 3. pass + + Args: + original_source: the original source. + modified_source: the modified source. + """ + matcher = difflib.SequenceMatcher( + None, + original_source.splitlines(keepends=True), + modified_source.splitlines(keepends=True), + ) + matching_blocks = matcher.get_matching_blocks() + lines_mappings: list[_LinesMapping] = [] + # matching_blocks is a sequence of "same block of code ranges", see + # https://docs.python.org/3/library/difflib.html#difflib.SequenceMatcher.get_matching_blocks + # Each block corresponds to a _LinesMapping with is_changed_block=False, + # and the ranges between two blocks corresponds to a _LinesMapping with + # is_changed_block=True, + # NOTE: matching_blocks is 0-based, but _LinesMapping is 1-based. + for i, block in enumerate(matching_blocks): + if i == 0: + if block.a != 0 or block.b != 0: + lines_mappings.append( + _LinesMapping( + original_start=1, + original_end=block.a, + modified_start=1, + modified_end=block.b, + is_changed_block=False, + ) + ) + else: + previous_block = matching_blocks[i - 1] + lines_mappings.append( + _LinesMapping( + original_start=previous_block.a + previous_block.size + 1, + original_end=block.a, + modified_start=previous_block.b + previous_block.size + 1, + modified_end=block.b, + is_changed_block=True, + ) + ) + if i < len(matching_blocks) - 1: + lines_mappings.append( + _LinesMapping( + original_start=block.a + 1, + original_end=block.a + block.size, + modified_start=block.b + 1, + modified_end=block.b + block.size, + is_changed_block=False, + ) + ) + return lines_mappings + + +def _find_lines_mapping_index( + original_line: int, + lines_mappings: Sequence[_LinesMapping], + start_index: int, +) -> int: + """Returns the original index of the lines mappings for the original line.""" + index = start_index + while index < len(lines_mappings): + mapping = lines_mappings[index] + if mapping.original_start <= original_line <= mapping.original_end: + return index + index += 1 + return index diff --git a/src/black/report.py b/src/black/report.py new file mode 100644 index 0000000..7b7a094 --- /dev/null +++ b/src/black/report.py @@ -0,0 +1,109 @@ +""" +Summarize Black runs to users. +""" + +from dataclasses import dataclass +from enum import Enum +from pathlib import Path + +from black.output import err, out, style_output + + +class Changed(Enum): + NO = 0 + CACHED = 1 + YES = 2 + + +class NothingChanged(UserWarning): + """Raised when reformatted code is the same as source.""" + + +@dataclass +class Report: + """Provides a reformatting counter. Can be rendered with `str(report)`.""" + + check: bool = False + diff: bool = False + quiet: bool = False + verbose: bool = False + change_count: int = 0 + same_count: int = 0 + failure_count: int = 0 + + def done(self, src: Path, changed: Changed) -> None: + """Increment the counter for successful reformatting. Write out a message.""" + if changed is Changed.YES: + reformatted = "would reformat" if self.check or self.diff else "reformatted" + if self.verbose or not self.quiet: + out(f"{reformatted} {src}") + self.change_count += 1 + else: + if self.verbose: + if changed is Changed.NO: + msg = f"{src} already well formatted, good job." + else: + msg = f"{src} wasn't modified on disk since last run." + out(msg, bold=False) + self.same_count += 1 + + def failed(self, src: Path, message: str) -> None: + """Increment the counter for failed reformatting. Write out a message.""" + err(f"error: cannot format {src}: {message}") + self.failure_count += 1 + + def path_ignored(self, path: Path, message: str) -> None: + if self.verbose: + out(f"{path} ignored: {message}", bold=False) + + @property + def return_code(self) -> int: + """Return the exit code that the app should use. + + This considers the current state of changed files and failures: + - if there were any failures, return 123; + - if any files were changed and --check is being used, return 1; + - otherwise return 0. + """ + # According to http://tldp.org/LDP/abs/html/exitcodes.html starting with + # 126 we have special return codes reserved by the shell. + if self.failure_count: + return 123 + + elif self.change_count and self.check: + return 1 + + return 0 + + def __str__(self) -> str: + """Render a color report of the current state. + + Use `click.unstyle` to remove colors. + """ + if self.check or self.diff: + reformatted = "would be reformatted" + unchanged = "would be left unchanged" + failed = "would fail to reformat" + else: + reformatted = "reformatted" + unchanged = "left unchanged" + failed = "failed to reformat" + report = [] + if self.change_count: + s = "s" if self.change_count > 1 else "" + report.append( + style_output(f"{self.change_count} file{s} ", bold=True, fg="blue") + + style_output(f"{reformatted}", bold=True) + ) + + if self.same_count: + s = "s" if self.same_count > 1 else "" + report.append( + style_output(f"{self.same_count} file{s} ", fg="blue") + unchanged + ) + if self.failure_count: + s = "s" if self.failure_count > 1 else "" + report.append( + style_output(f"{self.failure_count} file{s} {failed}", fg="red") + ) + return ", ".join(report) + "." diff --git a/src/black/resources/__init__.py b/src/black/resources/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/black/resources/black.schema.json b/src/black/resources/black.schema.json new file mode 100644 index 0000000..f467f1a --- /dev/null +++ b/src/black/resources/black.schema.json @@ -0,0 +1,161 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "$id": "https://github.com/psf/black/blob/main/src/black/resources/black.schema.json", + "$comment": "tool.black table in pyproject.toml", + "type": "object", + "additionalProperties": false, + "properties": { + "code": { + "type": "string", + "description": "Format the code passed in as a string." + }, + "line-length": { + "type": "integer", + "description": "How many characters per line to allow.", + "default": 88 + }, + "target-version": { + "type": "array", + "items": { + "enum": [ + "py33", + "py34", + "py35", + "py36", + "py37", + "py38", + "py39", + "py310", + "py311", + "py312", + "py313", + "py314", + "py315" + ] + }, + "description": "Python versions that should be supported by Black's output. You should include all versions that your code supports. By default, Black will infer target versions from the project metadata in pyproject.toml. If this does not yield conclusive results, Black will use per-file auto-detection." + }, + "pyi": { + "type": "boolean", + "description": "Format all input files like typing stubs regardless of file extension. This is useful when piping source on standard input.", + "default": false + }, + "ipynb": { + "type": "boolean", + "description": "Format all input files like Jupyter Notebooks regardless of file extension. This is useful when piping source on standard input.", + "default": false + }, + "python-cell-magics": { + "type": "array", + "items": { + "type": "string" + }, + "description": "When processing Jupyter Notebooks, add the given magic to the list of known python-magics (capture, prun, pypy, python, python3, time, timeit). Useful for formatting cells with custom python magics." + }, + "skip-source-first-line": { + "type": "boolean", + "description": "Skip the first line of the source code.", + "default": false + }, + "skip-string-normalization": { + "type": "boolean", + "description": "Don't normalize string quotes or prefixes.", + "default": false + }, + "skip-magic-trailing-comma": { + "type": "boolean", + "description": "Don't use trailing commas as a reason to split lines.", + "default": false + }, + "preview": { + "type": "boolean", + "description": "Enable potentially disruptive style changes that may be added to Black's main functionality in the next major release.", + "default": false + }, + "unstable": { + "type": "boolean", + "description": "Enable potentially disruptive style changes that have known bugs or are not currently expected to make it into the stable style Black's next major release. Implies --preview.", + "default": false + }, + "enable-unstable-feature": { + "type": "array", + "items": { + "enum": [ + "string_processing", + "hug_parens_with_braces_and_square_brackets", + "wrap_comprehension_in", + "simplify_power_operator_hugging", + "wrap_long_dict_values_in_parens", + "fix_if_guard_explosion_in_case_statement", + "pyi_overload_group_blank_lines", + "fix_unnecessary_parens_in_indexed_assignment", + "pyi_blank_line_before_decorated_class", + "pyi_blank_line_after_function_docstring", + "hug_comparator", + "parenthesize_tuple_in_yield" + ] + }, + "description": "Enable specific features included in the `--unstable` style. Requires `--preview`. No compatibility guarantees are provided on the behavior or existence of any unstable features." + }, + "check": { + "type": "boolean", + "description": "Don't write the files back, just return the status. Return code 0 means nothing would change. Return code 1 means some files would be reformatted. Return code 123 means there was an internal error.", + "default": false + }, + "diff": { + "type": "boolean", + "description": "Don't write the files back, just output a diff to indicate what changes Black would've made. They are printed to stdout so capturing them is simple.", + "default": false + }, + "color": { + "type": "boolean", + "description": "Show (or do not show) colored diff. Only applies when --diff is given.", + "default": false + }, + "fast": { + "type": "boolean", + "description": "By default, Black performs an AST safety check after formatting your code. The --fast flag turns off this check and the --safe flag explicitly enables it. [default: --safe]", + "default": false + }, + "required-version": { + "type": "string", + "description": "Require a specific version of Black to be running. This is useful for ensuring that all contributors to your project are using the same version, because different versions of Black may format code a little differently. This option can be set in a configuration file for consistent results across environments." + }, + "exclude": { + "type": "string", + "description": "A regular expression that matches files and directories that should be excluded on recursive searches. An empty value means no paths are excluded. Use forward slashes for directories on all platforms (Windows, too). By default, Black also ignores all paths listed in .gitignore. Changing this value will override all default exclusions. [default: /(\\.direnv|\\.eggs|\\.git|\\.hg|\\.ipynb_checkpoints|\\.mypy_cache|\\.nox|\\.pytest_cache|\\.ruff_cache|\\.tox|\\.svn|\\.venv|\\.vscode|__pypackages__|_build|buck-out|build|dist|venv)/]" + }, + "extend-exclude": { + "type": "string", + "description": "Like --exclude, but adds additional files and directories on top of the default values instead of overriding them." + }, + "force-exclude": { + "type": "string", + "description": "Like --exclude, but files and directories matching this regex will be excluded even when they are passed explicitly as arguments. This is useful when invoking Black programmatically on changed files, such as in a pre-commit hook or editor plugin." + }, + "include": { + "type": "string", + "description": "A regular expression that matches files and directories that should be included on recursive searches. An empty value means all files are included regardless of the name. Use forward slashes for directories on all platforms (Windows, too). Overrides all exclusions, including from .gitignore and command line options.", + "default": "(\\.pyi?|\\.ipynb)$" + }, + "workers": { + "type": "integer", + "description": "When Black formats multiple files, it may use a process pool to speed up formatting. This option controls the number of parallel workers. This can also be specified via the BLACK_NUM_WORKERS environment variable. Defaults to the number of CPUs in the system." + }, + "quiet": { + "type": "boolean", + "description": "Stop emitting all non-critical output. Error messages will still be emitted (which can silenced by 2>/dev/null).", + "default": false + }, + "verbose": { + "type": "boolean", + "description": "Emit messages about files that were not changed or were ignored due to exclusion patterns. If Black is using a configuration file, a message detailing which one it is using will be emitted.", + "default": false + }, + "no-cache": { + "type": "boolean", + "description": "Skip reading and writing the cache, forcing Black to reformat all included files.", + "default": false + } + } +} diff --git a/src/black/rusty.py b/src/black/rusty.py new file mode 100644 index 0000000..ebd4c05 --- /dev/null +++ b/src/black/rusty.py @@ -0,0 +1,28 @@ +"""An error-handling model influenced by that used by the Rust programming language + +See https://doc.rust-lang.org/book/ch09-00-error-handling.html. +""" + +from typing import Generic, TypeVar, Union + +T = TypeVar("T") +E = TypeVar("E", bound=Exception) + + +class Ok(Generic[T]): + def __init__(self, value: T) -> None: + self._value = value + + def ok(self) -> T: + return self._value + + +class Err(Generic[E]): + def __init__(self, e: E) -> None: + self._e = e + + def err(self) -> E: + return self._e + + +Result = Union[Ok[T], Err[E]] diff --git a/src/black/schema.py b/src/black/schema.py new file mode 100644 index 0000000..f534dbb --- /dev/null +++ b/src/black/schema.py @@ -0,0 +1,15 @@ +import importlib.resources +import json +from typing import Any + + +def get_schema(tool_name: str = "black") -> Any: + """Get the stored complete schema for black's settings.""" + assert tool_name == "black", "Only black is supported." + + pkg = "black.resources" + fname = "black.schema.json" + + schema = importlib.resources.files(pkg).joinpath(fname) + with schema.open(encoding="utf-8") as f: + return json.load(f) diff --git a/src/black/strings.py b/src/black/strings.py new file mode 100644 index 0000000..5bb3425 --- /dev/null +++ b/src/black/strings.py @@ -0,0 +1,393 @@ +""" +Simple formatting on strings. Further string formatting code is in trans.py. +""" + +import re +import sys +from functools import lru_cache +from re import Match, Pattern +from typing import Final + +from black._width_table import WIDTH_TABLE +from blib2to3.pytree import Leaf + +STRING_PREFIX_CHARS: Final = "fturbFTURB" # All possible string prefix characters. +STRING_PREFIX_RE: Final = re.compile( + r"^([" + STRING_PREFIX_CHARS + r"]*)(.*)$", re.DOTALL +) +UNICODE_ESCAPE_RE: Final = re.compile( + r"(?P\\+)(?P" + r"(u(?P[a-fA-F0-9]{4}))" # Character with 16-bit hex value xxxx + r"|(U(?P[a-fA-F0-9]{8}))" # Character with 32-bit hex value xxxxxxxx + r"|(x(?P[a-fA-F0-9]{2}))" # Character with hex value hh + r"|(N\{(?P[a-zA-Z0-9 \-]{2,})\})" # Character named name in the Unicode database + r")?", + re.VERBOSE, +) + + +def sub_twice(regex: Pattern[str], replacement: str, original: str) -> str: + """Replace `regex` with `replacement` twice on `original`. + + This is used by string normalization to perform replaces on + overlapping matches. + """ + return regex.sub(replacement, regex.sub(replacement, original)) + + +def has_triple_quotes(string: str) -> bool: + """ + Returns: + True iff @string starts with three quotation characters. + """ + raw_string = string.lstrip(STRING_PREFIX_CHARS) + return raw_string[:3] in {'"""', "'''"} + + +def lines_with_leading_tabs_expanded(s: str) -> list[str]: + """ + Splits string into lines and expands only leading tabs. + + Black normalizes code indentation to four-space columns, so leading tabs in + docstrings need the same width to keep relative indentation stable. + """ + lines = [] + for line in s.splitlines(): + stripped_line = line.lstrip() + if not stripped_line or stripped_line == line: + lines.append(line) + else: + prefix_length = len(line) - len(stripped_line) + prefix = line[:prefix_length].expandtabs(4) + lines.append(prefix + stripped_line) + if s.endswith("\n"): + lines.append("") + return lines + + +def fix_multiline_docstring(docstring: str, prefix: str) -> str: + # https://peps.python.org/pep-0257/#handling-docstring-indentation + assert docstring, "INTERNAL ERROR: Multiline docstrings cannot be empty" + lines = lines_with_leading_tabs_expanded(docstring) + # Determine minimum indentation (first line doesn't count): + indent = sys.maxsize + for line in lines[1:]: + stripped = line.lstrip() + if stripped: + indent = min(indent, len(line) - len(stripped)) + # Remove indentation (first line is special): + trimmed = [lines[0].strip()] + if indent < sys.maxsize: + last_line_idx = len(lines) - 2 + for i, line in enumerate(lines[1:]): + stripped_line = line[indent:].rstrip() + if stripped_line or i == last_line_idx: + trimmed.append(prefix + stripped_line) + else: + trimmed.append("") + return "\n".join(trimmed) + + +def get_string_prefix(string: str) -> str: + """ + Pre-conditions: + * assert_is_leaf_string(@string) + + Returns: + @string's prefix (e.g. '', 'r', 'f', or 'rf'). + """ + assert_is_leaf_string(string) + + prefix = [] + for char in string: + if char in STRING_PREFIX_CHARS: + prefix.append(char) + else: + break + return "".join(prefix) + + +def assert_is_leaf_string(string: str) -> None: + """ + Checks the pre-condition that @string has the format that you would expect + of `leaf.value` where `leaf` is some Leaf such that `leaf.type == + token.STRING`. A more precise description of the pre-conditions that are + checked are listed below. + + Pre-conditions: + * @string starts with either ', ", ', or " where + `set()` is some subset of `set(STRING_PREFIX_CHARS)`. + * @string ends with a quote character (' or "). + + Raises: + AssertionError(...) if the pre-conditions listed above are not + satisfied. + """ + dquote_idx = string.find('"') + squote_idx = string.find("'") + if -1 in [dquote_idx, squote_idx]: + quote_idx = max(dquote_idx, squote_idx) + else: + quote_idx = min(squote_idx, dquote_idx) + + assert ( + 0 <= quote_idx < len(string) - 1 + ), f"{string!r} is missing a starting quote character (' or \")." + assert string[-1] in ( + "'", + '"', + ), f"{string!r} is missing an ending quote character (' or \")." + assert set(string[:quote_idx]).issubset( + set(STRING_PREFIX_CHARS) + ), f"{set(string[:quote_idx])} is NOT a subset of {set(STRING_PREFIX_CHARS)}." + + +def normalize_string_prefix(s: str) -> str: + """Make all string prefixes lowercase.""" + match = STRING_PREFIX_RE.match(s) + assert match is not None, f"failed to match string {s!r}" + orig_prefix = match.group(1) + new_prefix = ( + orig_prefix.replace("F", "f") + .replace("B", "b") + .replace("U", "") + .replace("u", "") + ) + + # Python syntax guarantees max 2 prefixes and that one of them is "r" + if len(new_prefix) == 2 and new_prefix[0].lower() != "r": + new_prefix = new_prefix[::-1] + return f"{new_prefix}{match.group(2)}" + + +# Re(gex) does actually cache patterns internally but this still improves +# performance on a long list literal of strings by 5-9% since lru_cache's +# caching overhead is much lower. +@lru_cache(maxsize=64) +def _cached_compile(pattern: str) -> Pattern[str]: + return re.compile(pattern) + + +def normalize_string_quotes(s: str) -> str: + """Prefer double quotes but only if it doesn't cause more escaping. + + Adds or removes backslashes as appropriate. + """ + value = s.lstrip(STRING_PREFIX_CHARS) + if value[:3] == '"""': + return s + + elif value[:3] == "'''": + orig_quote = "'''" + new_quote = '"""' + elif value[0] == '"': + orig_quote = '"' + new_quote = "'" + else: + orig_quote = "'" + new_quote = '"' + first_quote_pos = s.find(orig_quote) + assert first_quote_pos != -1, f"INTERNAL ERROR: Malformed string {s!r}" + + prefix = s[:first_quote_pos] + unescaped_new_quote = _cached_compile(rf"(([^\\]|^)(\\\\)*){new_quote}") + escaped_new_quote = _cached_compile(rf"([^\\]|^)\\((?:\\\\)*){new_quote}") + escaped_orig_quote = _cached_compile(rf"([^\\]|^)\\((?:\\\\)*){orig_quote}") + body = s[first_quote_pos + len(orig_quote) : -len(orig_quote)] + if "r" in prefix.casefold(): + if unescaped_new_quote.search(body): + # There's at least one unescaped new_quote in this raw string + # so converting is impossible + return s + + # Do not introduce or remove backslashes in raw strings + new_body = body + else: + # remove unnecessary escapes + new_body = sub_twice(escaped_new_quote, rf"\1\2{new_quote}", body) + if body != new_body: + # Consider the string without unnecessary escapes as the original + body = new_body + s = f"{prefix}{orig_quote}{body}{orig_quote}" + new_body = sub_twice(escaped_orig_quote, rf"\1\2{orig_quote}", new_body) + new_body = sub_twice(unescaped_new_quote, rf"\1\\{new_quote}", new_body) + + if "f" in prefix.casefold(): + matches = re.findall( + r""" + (?:(? orig_escape_count: + return s # Do not introduce more escaping + + if new_escape_count == orig_escape_count and orig_quote == '"': + return s # Prefer double quotes + + return f"{prefix}{new_quote}{new_body}{new_quote}" + + +def normalize_fstring_quotes( + quote: str, + middles: list[Leaf], + is_raw_fstring: bool, +) -> tuple[list[Leaf], str]: + """Prefer double quotes but only if it doesn't cause more escaping. + + Adds or removes backslashes as appropriate. + """ + if quote == '"""': + return middles, quote + + elif quote == "'''": + new_quote = '"""' + elif quote == '"': + new_quote = "'" + else: + new_quote = '"' + + unescaped_new_quote = _cached_compile(rf"(([^\\]|^)(\\\\)*){new_quote}") + escaped_new_quote = _cached_compile(rf"([^\\]|^)\\((?:\\\\)*){new_quote}") + escaped_orig_quote = _cached_compile(rf"([^\\]|^)\\((?:\\\\)*){quote}") + if is_raw_fstring: + for middle in middles: + if unescaped_new_quote.search(middle.value): + # There's at least one unescaped new_quote in this raw string + # so converting is impossible + return middles, quote + + # Do not introduce or remove backslashes in raw strings, just use double quote + return middles, '"' + + new_segments = [] + for middle in middles: + segment = middle.value + # remove unnecessary escapes + new_segment = sub_twice(escaped_new_quote, rf"\1\2{new_quote}", segment) + if segment != new_segment: + # Consider the string without unnecessary escapes as the original + middle.value = new_segment + + new_segment = sub_twice(escaped_orig_quote, rf"\1\2{quote}", new_segment) + new_segment = sub_twice(unescaped_new_quote, rf"\1\\{new_quote}", new_segment) + new_segments.append(new_segment) + + if new_quote == '"""' and new_segments[-1].endswith('"'): + # edge case: + new_segments[-1] = new_segments[-1][:-1] + '\\"' + + orig_escape_count = 0 + new_escape_count = 0 + for middle, new_segment in zip(middles, new_segments, strict=True): + orig_escape_count += middle.value.count("\\") + new_escape_count += new_segment.count("\\") + + if new_escape_count > orig_escape_count: + return middles, quote # Do not introduce more escaping + + if new_escape_count == orig_escape_count and quote == '"': + return middles, quote # Prefer double quotes + + for middle, new_segment in zip(middles, new_segments, strict=True): + middle.value = new_segment + + return middles, new_quote + + +def normalize_unicode_escape_sequences(leaf: Leaf) -> None: + """Replace hex codes in Unicode escape sequences with lowercase representation.""" + text = leaf.value + prefix = get_string_prefix(text) + if "r" in prefix.lower(): + return + + def replace(m: Match[str]) -> str: + groups = m.groupdict() + back_slashes = groups["backslashes"] + + if groups["body"] is None or len(back_slashes) % 2 == 0: + return m.group(0) + + if groups["u"]: + # \u + return back_slashes + "u" + groups["u"].lower() + elif groups["U"]: + # \U + return back_slashes + "U" + groups["U"].lower() + elif groups["x"]: + # \x + return back_slashes + "x" + groups["x"].lower() + else: + assert groups["N"], f"Unexpected match: {m}" + # \N{} + return back_slashes + "N{" + groups["N"].upper() + "}" + + leaf.value = re.sub(UNICODE_ESCAPE_RE, replace, text) + + +@lru_cache(maxsize=4096) +def char_width(char: str) -> int: + """Return the width of a single character as it would be displayed in a + terminal or editor (which respects Unicode East Asian Width). + + Full width characters are counted as 2, while half width characters are + counted as 1. Also control characters are counted as 0. + """ + table = WIDTH_TABLE + codepoint = ord(char) + highest = len(table) - 1 + lowest = 0 + idx = highest // 2 + while True: + start_codepoint, end_codepoint, width = table[idx] + if codepoint < start_codepoint: + highest = idx - 1 + elif codepoint > end_codepoint: + lowest = idx + 1 + else: + return 0 if width < 0 else width + if highest < lowest: + break + idx = (highest + lowest) // 2 + return 1 + + +def str_width(line_str: str) -> int: + """Return the width of `line_str` as it would be displayed in a terminal + or editor (which respects Unicode East Asian Width). + + You could utilize this function to determine, for example, if a string + is too wide to display in a terminal or editor. + """ + if line_str.isascii(): + # Fast path for a line consisting of only ASCII characters + return len(line_str) + return sum(map(char_width, line_str)) + + +def count_chars_in_width(line_str: str, max_width: int) -> int: + """Count the number of characters in `line_str` that would fit in a + terminal or editor of `max_width` (which respects Unicode East Asian + Width). + """ + total_width = 0 + for i, char in enumerate(line_str): + width = char_width(char) + if width + total_width > max_width: + return i + total_width += width + return len(line_str) diff --git a/src/black/trans.py b/src/black/trans.py new file mode 100644 index 0000000..8d1bd27 --- /dev/null +++ b/src/black/trans.py @@ -0,0 +1,2597 @@ +""" +String transformers that can split and merge strings. +""" + +import re +from abc import ABC, abstractmethod +from collections import defaultdict +from collections.abc import Callable, Collection, Iterable, Iterator, Sequence +from dataclasses import dataclass +from typing import Any, ClassVar, Final, Literal, TypeVar, Union + +from mypy_extensions import trait + +from black.comments import contains_pragma_comment +from black.lines import Line, append_leaves +from black.mode import Feature, Mode +from black.nodes import ( + CLOSING_BRACKETS, + OPENING_BRACKETS, + STANDALONE_COMMENT, + is_empty_lpar, + is_empty_par, + is_empty_rpar, + is_part_of_annotation, + parent_type, + replace_child, + syms, +) +from black.rusty import Err, Ok, Result +from black.strings import ( + assert_is_leaf_string, + count_chars_in_width, + get_string_prefix, + has_triple_quotes, + normalize_string_quotes, + str_width, +) +from blib2to3.pgen2 import token +from blib2to3.pytree import Leaf, Node + + +class CannotTransform(Exception): + """Base class for errors raised by Transformers.""" + + +# types +T = TypeVar("T") +LN = Union[Leaf, Node] +Transformer = Callable[[Line, Collection[Feature], Mode], Iterator[Line]] +Index = int +NodeType = int +ParserState = int +StringID = int +TResult = Result[T, CannotTransform] # (T)ransform Result +TMatchResult = TResult[list[Index]] + +SPLIT_SAFE_CHARS = frozenset(["\u3001", "\u3002", "\uff0c"]) # East Asian stops + + +def TErr(err_msg: str) -> Err[CannotTransform]: + """(T)ransform Err + + Convenience function used when working with the TResult type. + """ + cant_transform = CannotTransform(err_msg) + return Err(cant_transform) + + +# Remove when `simplify_power_operator_hugging` becomes stable. +def hug_power_op( + line: Line, features: Collection[Feature], mode: Mode +) -> Iterator[Line]: + """A transformer which normalizes spacing around power operators.""" + + # Performance optimization to avoid unnecessary Leaf clones and other ops. + for leaf in line.leaves: + if leaf.type == token.DOUBLESTAR: + break + else: + raise CannotTransform("No doublestar token was found in the line.") + + def is_simple_lookup(index: int, kind: Literal[1, -1]) -> bool: + # Brackets and parentheses indicate calls, subscripts, etc. ... + # basically stuff that doesn't count as "simple". Only a NAME lookup + # or dotted lookup (eg. NAME.NAME) is OK. + if kind == -1: + return handle_is_simple_look_up_prev(line, index, {token.RPAR, token.RSQB}) + else: + return handle_is_simple_lookup_forward( + line, index, {token.LPAR, token.LSQB} + ) + + def is_simple_operand(index: int, kind: Literal[1, -1]) -> bool: + # An operand is considered "simple" if's a NAME, a numeric CONSTANT, a simple + # lookup (see above), with or without a preceding unary operator. + start = line.leaves[index] + if start.type in {token.NAME, token.NUMBER}: + return is_simple_lookup(index, kind) + + if start.type in {token.PLUS, token.MINUS, token.TILDE}: + if line.leaves[index + 1].type in {token.NAME, token.NUMBER}: + # kind is always one as bases with a preceding unary op will be checked + # for simplicity starting from the next token (so it'll hit the check + # above). + return is_simple_lookup(index + 1, kind=1) + + return False + + new_line = line.clone() + should_hug = False + for idx, leaf in enumerate(line.leaves): + new_leaf = leaf.clone() + if should_hug: + new_leaf.prefix = "" + should_hug = False + + should_hug = ( + (0 < idx < len(line.leaves) - 1) + and leaf.type == token.DOUBLESTAR + and is_simple_operand(idx - 1, kind=-1) + and line.leaves[idx - 1].value != "lambda" + and is_simple_operand(idx + 1, kind=1) + ) + if should_hug: + new_leaf.prefix = "" + + # We have to be careful to make a new line properly: + # - bracket related metadata must be maintained (handled by Line.append) + # - comments need to copied over, updating the leaf IDs they're attached to + new_line.append(new_leaf, preformatted=True) + for comment_leaf in line.comments_after(leaf): + new_line.append(comment_leaf, preformatted=True) + + yield new_line + + +# Remove when `simplify_power_operator_hugging` becomes stable. +def handle_is_simple_look_up_prev(line: Line, index: int, disallowed: set[int]) -> bool: + """ + Handling the determination of is_simple_lookup for the lines prior to the doublestar + token. This is required because of the need to isolate the chained expression + to determine the bracket or parenthesis belong to the single expression. + """ + contains_disallowed = False + chain = [] + + while 0 <= index < len(line.leaves): + current = line.leaves[index] + chain.append(current) + if not contains_disallowed and current.type in disallowed: + contains_disallowed = True + if not is_expression_chained(chain): + return not contains_disallowed + + index -= 1 + + return True + + +# Remove when `simplify_power_operator_hugging` becomes stable. +def handle_is_simple_lookup_forward( + line: Line, index: int, disallowed: set[int] +) -> bool: + """ + Handling decision is_simple_lookup for the lines behind the doublestar token. + This function is simplified to keep consistent with the prior logic and the forward + case are more straightforward and do not need to care about chained expressions. + """ + while 0 <= index < len(line.leaves): + current = line.leaves[index] + if current.type in disallowed: + return False + if current.type not in {token.NAME, token.DOT} or ( + current.type == token.NAME and current.value == "for" + ): + # If the current token isn't disallowed, we'll assume this is simple as + # only the disallowed tokens are semantically attached to this lookup + # expression we're checking. Also, stop early if we hit the 'for' bit + # of a comprehension. + return True + + index += 1 + + return True + + +# Remove when `simplify_power_operator_hugging` becomes stable. +def is_expression_chained(chained_leaves: list[Leaf]) -> bool: + """ + Function to determine if the variable is a chained call. + (e.g., foo.lookup, foo().lookup, (foo.lookup())) will be recognized as chained call) + """ + if len(chained_leaves) < 2: + return True + + current_leaf = chained_leaves[-1] + past_leaf = chained_leaves[-2] + + if past_leaf.type == token.NAME: + return current_leaf.type in {token.DOT} + elif past_leaf.type in {token.RPAR, token.RSQB}: + return current_leaf.type in {token.RSQB, token.RPAR} + elif past_leaf.type in {token.LPAR, token.LSQB}: + return current_leaf.type in {token.NAME, token.LPAR, token.LSQB} + else: + return False + + +class StringTransformer(ABC): + """ + An implementation of the Transformer protocol that relies on its + subclasses overriding the template methods `do_match(...)` and + `do_transform(...)`. + + This Transformer works exclusively on strings (for example, by merging + or splitting them). + + The following sections can be found among the docstrings of each concrete + StringTransformer subclass. + + Requirements: + Which requirements must be met of the given Line for this + StringTransformer to be applied? + + Transformations: + If the given Line meets all of the above requirements, which string + transformations can you expect to be applied to it by this + StringTransformer? + + Collaborations: + What contractual agreements does this StringTransformer have with other + StringTransformers? Such collaborations should be eliminated/minimized + as much as possible. + """ + + __name__: Final = "StringTransformer" + + # Ideally this would be a dataclass, but unfortunately mypyc breaks when used with + # `abc.ABC`. + def __init__(self, line_length: int, normalize_strings: bool) -> None: + self.line_length = line_length + self.normalize_strings = normalize_strings + + @abstractmethod + def do_match(self, line: Line) -> TMatchResult: + """ + Returns: + * Ok(string_indices) such that for each index, `line.leaves[index]` + is our target string if a match was able to be made. For + transformers that don't result in more lines (e.g. StringMerger, + StringParenStripper), multiple matches and transforms are done at + once to reduce the complexity. + OR + * Err(CannotTransform), if no match could be made. + """ + + @abstractmethod + def do_transform( + self, line: Line, string_indices: list[int] + ) -> Iterator[TResult[Line]]: + """ + Yields: + * Ok(new_line) where new_line is the new transformed line. + OR + * Err(CannotTransform) if the transformation failed for some reason. The + `do_match(...)` template method should usually be used to reject + the form of the given Line, but in some cases it is difficult to + know whether or not a Line meets the StringTransformer's + requirements until the transformation is already midway. + + Side Effects: + This method should NOT mutate @line directly, but it MAY mutate the + Line's underlying Node structure. (WARNING: If the underlying Node + structure IS altered, then this method should NOT be allowed to + yield an CannotTransform after that point.) + """ + + def __call__( + self, line: Line, _features: Collection[Feature], _mode: Mode + ) -> Iterator[Line]: + """ + StringTransformer instances have a call signature that mirrors that of + the Transformer type. + + Raises: + CannotTransform(...) if the concrete StringTransformer class is unable + to transform @line. + """ + # Optimization to avoid calling `self.do_match(...)` when the line does + # not contain any string. + if not any(leaf.type == token.STRING for leaf in line.leaves): + raise CannotTransform("There are no strings in this line.") + + match_result = self.do_match(line) + + if isinstance(match_result, Err): + cant_transform = match_result.err() + raise CannotTransform( + f"The string transformer {self.__class__.__name__} does not recognize" + " this line as one that it can transform." + ) from cant_transform + + string_indices = match_result.ok() + + for line_result in self.do_transform(line, string_indices): + if isinstance(line_result, Err): + cant_transform = line_result.err() + raise CannotTransform( + "StringTransformer failed while attempting to transform string." + ) from cant_transform + line = line_result.ok() + yield line + + +@dataclass +class CustomSplit: + """A custom (i.e. manual) string split. + + A single CustomSplit instance represents a single substring. + + Examples: + Consider the following string: + ``` + "Hi there friend." + " This is a custom" + f" string {split}." + ``` + + This string will correspond to the following three CustomSplit instances: + ``` + CustomSplit(False, 16) + CustomSplit(False, 17) + CustomSplit(True, 16) + ``` + """ + + has_prefix: bool + break_idx: int + + +CustomSplitMapKey = tuple[StringID, str] + + +@trait +class CustomSplitMapMixin: + """ + This mixin class is used to map merged strings to a sequence of + CustomSplits, which will then be used to re-split the strings iff none of + the resultant substrings go over the configured max line length. + """ + + _CUSTOM_SPLIT_MAP: ClassVar[dict[CustomSplitMapKey, tuple[CustomSplit, ...]]] = ( + defaultdict(tuple) + ) + + @staticmethod + def _get_key(string: str) -> CustomSplitMapKey: + """ + Returns: + A unique identifier that is used internally to map @string to a + group of custom splits. + """ + return (id(string), string) + + def add_custom_splits( + self, string: str, custom_splits: Iterable[CustomSplit] + ) -> None: + """Custom Split Map Setter Method + + Side Effects: + Adds a mapping from @string to the custom splits @custom_splits. + """ + key = self._get_key(string) + self._CUSTOM_SPLIT_MAP[key] = tuple(custom_splits) + + def pop_custom_splits(self, string: str) -> list[CustomSplit]: + """Custom Split Map Getter Method + + Returns: + * A list of the custom splits that are mapped to @string, if any + exist. + OR + * [], otherwise. + + Side Effects: + Deletes the mapping between @string and its associated custom + splits (which are returned to the caller). + """ + key = self._get_key(string) + + custom_splits = self._CUSTOM_SPLIT_MAP[key] + del self._CUSTOM_SPLIT_MAP[key] + + return list(custom_splits) + + def has_custom_splits(self, string: str) -> bool: + """ + Returns: + True iff @string is associated with a set of custom splits. + """ + key = self._get_key(string) + return key in self._CUSTOM_SPLIT_MAP + + +class StringMerger(StringTransformer, CustomSplitMapMixin): + """StringTransformer that merges strings together. + + Requirements: + (A) The line contains adjacent strings such that ALL of the validation checks + listed in StringMerger._validate_msg(...)'s docstring pass. + OR + (B) The line contains a string which uses line continuation backslashes. + + Transformations: + Depending on which of the two requirements above where met, either: + + (A) The string group associated with the target string is merged. + OR + (B) All line-continuation backslashes are removed from the target string. + + Collaborations: + StringMerger provides custom split information to StringSplitter. + """ + + def do_match(self, line: Line) -> TMatchResult: + LL = line.leaves + + is_valid_index = is_valid_index_factory(LL) + + string_indices = [] + idx = 0 + while is_valid_index(idx): + leaf = LL[idx] + if ( + leaf.type == token.STRING + and is_valid_index(idx + 1) + and LL[idx + 1].type == token.STRING + ): + # Let's check if the string group contains an inline comment + # If we have a comment inline, we don't merge the strings + contains_comment = False + i = idx + while is_valid_index(i): + if LL[i].type != token.STRING: + break + if line.comments_after(LL[i]): + contains_comment = True + break + i += 1 + + if not contains_comment and not is_part_of_annotation(leaf): + string_indices.append(idx) + + # Advance to the next non-STRING leaf. + idx += 2 + while is_valid_index(idx) and LL[idx].type == token.STRING: + idx += 1 + + elif leaf.type == token.STRING and "\\\n" in leaf.value: + string_indices.append(idx) + # Advance to the next non-STRING leaf. + idx += 1 + while is_valid_index(idx) and LL[idx].type == token.STRING: + idx += 1 + + else: + idx += 1 + + if string_indices: + return Ok(string_indices) + else: + return TErr("This line has no strings that need merging.") + + def do_transform( + self, line: Line, string_indices: list[int] + ) -> Iterator[TResult[Line]]: + new_line = line + + rblc_result = self._remove_backslash_line_continuation_chars( + new_line, string_indices + ) + if isinstance(rblc_result, Ok): + new_line = rblc_result.ok() + + msg_result = self._merge_string_group(new_line, string_indices) + if isinstance(msg_result, Ok): + new_line = msg_result.ok() + + if isinstance(rblc_result, Err) and isinstance(msg_result, Err): + msg_cant_transform = msg_result.err() + rblc_cant_transform = rblc_result.err() + cant_transform = CannotTransform( + "StringMerger failed to merge any strings in this line." + ) + + # Chain the errors together using `__cause__`. + msg_cant_transform.__cause__ = rblc_cant_transform + cant_transform.__cause__ = msg_cant_transform + + yield Err(cant_transform) + else: + yield Ok(new_line) + + @staticmethod + def _remove_backslash_line_continuation_chars( + line: Line, string_indices: list[int] + ) -> TResult[Line]: + """ + Merge strings that were split across multiple lines using + line-continuation backslashes. + + Returns: + Ok(new_line), if @line contains backslash line-continuation + characters. + OR + Err(CannotTransform), otherwise. + """ + LL = line.leaves + + indices_to_transform = [] + for string_idx in string_indices: + string_leaf = LL[string_idx] + if ( + string_leaf.type == token.STRING + and "\\\n" in string_leaf.value + and not has_triple_quotes(string_leaf.value) + ): + indices_to_transform.append(string_idx) + + if not indices_to_transform: + return TErr( + "Found no string leaves that contain backslash line continuation" + " characters." + ) + + new_line = line.clone() + new_line.comments = line.comments.copy() + append_leaves(new_line, line, LL) + + for string_idx in indices_to_transform: + new_string_leaf = new_line.leaves[string_idx] + new_string_leaf.value = new_string_leaf.value.replace("\\\n", "") + + return Ok(new_line) + + def _merge_string_group( + self, line: Line, string_indices: list[int] + ) -> TResult[Line]: + """ + Merges string groups (i.e. set of adjacent strings). + + Each index from `string_indices` designates one string group's first + leaf in `line.leaves`. + + Returns: + Ok(new_line), if ALL of the validation checks found in + _validate_msg(...) pass. + OR + Err(CannotTransform), otherwise. + """ + LL = line.leaves + + is_valid_index = is_valid_index_factory(LL) + + # A dict of {string_idx: tuple[num_of_strings, string_leaf]}. + merged_string_idx_dict: dict[int, tuple[int, Leaf]] = {} + for string_idx in string_indices: + vresult = self._validate_msg(line, string_idx) + if isinstance(vresult, Err): + continue + merged_string_idx_dict[string_idx] = self._merge_one_string_group( + LL, string_idx, is_valid_index + ) + + if not merged_string_idx_dict: + return TErr("No string group is merged") + + # Build the final line ('new_line') that this method will later return. + new_line = line.clone() + previous_merged_string_idx = -1 + previous_merged_num_of_strings = -1 + for i, leaf in enumerate(LL): + if i in merged_string_idx_dict: + previous_merged_string_idx = i + previous_merged_num_of_strings, string_leaf = merged_string_idx_dict[i] + new_line.append(string_leaf) + + if ( + previous_merged_string_idx + <= i + < previous_merged_string_idx + previous_merged_num_of_strings + ): + for comment_leaf in line.comments_after(leaf): + new_line.append(comment_leaf, preformatted=True) + continue + + append_leaves(new_line, line, [leaf]) + + return Ok(new_line) + + def _merge_one_string_group( + self, LL: list[Leaf], string_idx: int, is_valid_index: Callable[[int], bool] + ) -> tuple[int, Leaf]: + """ + Merges one string group where the first string in the group is + `LL[string_idx]`. + + Returns: + A tuple of `(num_of_strings, leaf)` where `num_of_strings` is the + number of strings merged and `leaf` is the newly merged string + to be replaced in the new line. + """ + # If the string group is wrapped inside an Atom node, we must make sure + # to later replace that Atom with our new (merged) string leaf. + atom_node = LL[string_idx].parent + + # We will place BREAK_MARK in between every two substrings that we + # merge. We will then later go through our final result and use the + # various instances of BREAK_MARK we find to add the right values to + # the custom split map. + BREAK_MARK = "@@@@@ BLACK BREAKPOINT MARKER @@@@@" + + QUOTE = LL[string_idx].value[-1] + + def make_naked(string: str, string_prefix: str) -> str: + """Strip @string (i.e. make it a "naked" string) + + Pre-conditions: + * assert_is_leaf_string(@string) + + Returns: + A string that is identical to @string except that + @string_prefix has been stripped, the surrounding QUOTE + characters have been removed, and any remaining QUOTE + characters have been escaped. + """ + assert_is_leaf_string(string) + if "f" in string_prefix: + f_expressions = [ + string[span[0] + 1 : span[1] - 1] # +-1 to get rid of curly braces + for span in iter_fexpr_spans(string) + ] + debug_expressions_contain_visible_quotes = any( + re.search(r"[\'\"].*(?= 0 + ), "Logic error while filling the custom string breakpoint cache." + + temp_string = temp_string[mark_idx + len(BREAK_MARK) :] + breakpoint_idx = mark_idx + (len(prefix) if has_prefix else 0) + 1 + custom_splits.append(CustomSplit(has_prefix, breakpoint_idx)) + + string_leaf = Leaf(token.STRING, S_leaf.value.replace(BREAK_MARK, "")) + + if atom_node is not None: + # If not all children of the atom node are merged (this can happen + # when there is a standalone comment in the middle) ... + if non_string_idx - string_idx < len(atom_node.children): + # We need to replace the old STRING leaves with the new string leaf. + first_child_idx = LL[string_idx].remove() + for idx in range(string_idx + 1, non_string_idx): + LL[idx].remove() + if first_child_idx is not None: + atom_node.insert_child(first_child_idx, string_leaf) + else: + # Else replace the atom node with the new string leaf. + replace_child(atom_node, string_leaf) + + self.add_custom_splits(string_leaf.value, custom_splits) + return num_of_strings, string_leaf + + @staticmethod + def _validate_msg(line: Line, string_idx: int) -> TResult[None]: + """Validate (M)erge (S)tring (G)roup + + Transform-time string validation logic for _merge_string_group(...). + + Returns: + * Ok(None), if ALL validation checks (listed below) pass. + OR + * Err(CannotTransform), if any of the following are true: + - The target string group does not contain ANY stand-alone comments. + - The target string is not in a string group (i.e. it has no + adjacent strings). + - The string group has more than one inline comment. + - The string group has an inline comment that appears to be a pragma. + - The set of all string prefixes in the string group is of + length greater than one and is not equal to {"", "f"}. + - The string group consists of raw strings. + - The string group would merge f-strings with different quote types + and internal quotes. + - The string group is stringified type annotations. We don't want to + process stringified type annotations since pyright doesn't support + them spanning multiple string values. (NOTE: mypy, pytype, pyre do + support them, so we can change if pyright also gains support in the + future. See https://github.com/microsoft/pyright/issues/4359.) + """ + # We first check for "inner" stand-alone comments (i.e. stand-alone + # comments that have a string leaf before them AND after them). + for inc in [1, -1]: + i = string_idx + found_sa_comment = False + is_valid_index = is_valid_index_factory(line.leaves) + while is_valid_index(i) and line.leaves[i].type in [ + token.STRING, + STANDALONE_COMMENT, + ]: + if line.leaves[i].type == STANDALONE_COMMENT: + found_sa_comment = True + elif found_sa_comment: + return TErr( + "StringMerger does NOT merge string groups which contain " + "stand-alone comments." + ) + + i += inc + + QUOTE = line.leaves[string_idx].value[-1] + + num_of_inline_string_comments = 0 + set_of_prefixes = set() + num_of_strings = 0 + for leaf in line.leaves[string_idx:]: + if leaf.type != token.STRING: + # If the string group is trailed by a comma, we count the + # comments trailing the comma to be one of the string group's + # comments. + if leaf.type == token.COMMA and id(leaf) in line.comments: + num_of_inline_string_comments += 1 + break + + if has_triple_quotes(leaf.value): + return TErr("StringMerger does NOT merge multiline strings.") + + num_of_strings += 1 + prefix = get_string_prefix(leaf.value).lower() + if "r" in prefix: + return TErr("StringMerger does NOT merge raw strings.") + + set_of_prefixes.add(prefix) + + if ( + "f" in prefix + and leaf.value[-1] != QUOTE + and ( + "'" in leaf.value[len(prefix) + 1 : -1] + or '"' in leaf.value[len(prefix) + 1 : -1] + ) + ): + return TErr( + "StringMerger does NOT merge f-strings with different quote types" + " and internal quotes." + ) + + if id(leaf) in line.comments: + num_of_inline_string_comments += 1 + if contains_pragma_comment(line.comments[id(leaf)]): + return TErr("Cannot merge strings which have pragma comments.") + + if num_of_strings < 2: + return TErr( + f"Not enough strings to merge (num_of_strings={num_of_strings})." + ) + + # Also check for pragma comments on tokens that follow the string + # group (e.g. a closing bracket). Merging strings when a pragma + # comment like `# type: ignore` follows would produce an unsplittable + # long line. + is_valid_index = is_valid_index_factory(line.leaves) + next_idx = string_idx + num_of_strings + while is_valid_index(next_idx): + next_leaf = line.leaves[next_idx] + if id(next_leaf) in line.comments: + if contains_pragma_comment(line.comments[id(next_leaf)]): + return TErr( + "Cannot merge strings when a pragma comment follows" + " the string group." + ) + if next_leaf.type not in CLOSING_BRACKETS: + break + next_idx += 1 + + if num_of_inline_string_comments > 1: + return TErr( + f"Too many inline string comments ({num_of_inline_string_comments})." + ) + + if len(set_of_prefixes) > 1 and set_of_prefixes != {"", "f"}: + return TErr(f"Too many different prefixes ({set_of_prefixes}).") + + return Ok(None) + + +class StringParenStripper(StringTransformer): + """StringTransformer that strips surrounding parentheses from strings. + + Requirements: + The line contains a string which is surrounded by parentheses and: + - The target string is NOT the only argument to a function call. + - The target string is NOT a "pointless" string. + - The target string is NOT a dictionary value. + - If the target string contains a PERCENT, the brackets are not + preceded or followed by an operator with higher precedence than + PERCENT. + + Transformations: + The parentheses mentioned in the 'Requirements' section are stripped. + + Collaborations: + StringParenStripper has its own inherent usefulness, but it is also + relied on to clean up the parentheses created by StringParenWrapper (in + the event that they are no longer needed). + """ + + def do_match(self, line: Line) -> TMatchResult: + LL = line.leaves + + is_valid_index = is_valid_index_factory(LL) + + string_indices = [] + + idx = -1 + while True: + idx += 1 + if idx >= len(LL): + break + leaf = LL[idx] + + # Should be a string... + if leaf.type != token.STRING: + continue + + # If this is a "pointless" string... + if ( + leaf.parent + and leaf.parent.parent + and leaf.parent.parent.type == syms.simple_stmt + ): + continue + + # Should be preceded by a non-empty LPAR... + if ( + not is_valid_index(idx - 1) + or LL[idx - 1].type != token.LPAR + or is_empty_lpar(LL[idx - 1]) + ): + continue + + # That LPAR should NOT be preceded by a colon (which could be a + # dictionary value), function name, or a closing bracket (which + # could be a function returning a function or a list/dictionary + # containing a function)... + if is_valid_index(idx - 2) and ( + LL[idx - 2].type == token.COLON + or LL[idx - 2].type == token.NAME + or LL[idx - 2].type in CLOSING_BRACKETS + ): + continue + + string_idx = idx + + # Skip the string trailer, if one exists. + string_parser = StringParser() + next_idx = string_parser.parse(LL, string_idx) + + # if the leaves in the parsed string include a PERCENT, we need to + # make sure the initial LPAR is NOT preceded by an operator with + # higher or equal precedence to PERCENT + if is_valid_index(idx - 2): + # mypy can't quite follow unless we name this + before_lpar = LL[idx - 2] + if token.PERCENT in {leaf.type for leaf in LL[idx - 1 : next_idx]} and ( + ( + before_lpar.type in { + token.STAR, + token.AT, + token.SLASH, + token.DOUBLESLASH, + token.PERCENT, + token.TILDE, + token.DOUBLESTAR, + token.AWAIT, + token.LSQB, + token.LPAR, + } + ) + or ( + # only unary PLUS/MINUS + before_lpar.parent + and before_lpar.parent.type == syms.factor + and (before_lpar.type in {token.PLUS, token.MINUS}) + ) + ): + continue + + # Should be followed by a non-empty RPAR... + if ( + is_valid_index(next_idx) + and LL[next_idx].type == token.RPAR + and not is_empty_rpar(LL[next_idx]) + ): + # That RPAR should NOT be followed by anything with higher + # precedence than PERCENT + if is_valid_index(next_idx + 1) and LL[next_idx + 1].type in { + token.DOUBLESTAR, + token.LSQB, + token.LPAR, + token.DOT, + }: + continue + + string_indices.append(string_idx) + idx = string_idx + while idx < len(LL) - 1 and LL[idx + 1].type == token.STRING: + idx += 1 + + if string_indices: + return Ok(string_indices) + return TErr("This line has no strings wrapped in parens.") + + def do_transform( + self, line: Line, string_indices: list[int] + ) -> Iterator[TResult[Line]]: + LL = line.leaves + + string_and_rpar_indices: list[int] = [] + for string_idx in string_indices: + string_parser = StringParser() + rpar_idx = string_parser.parse(LL, string_idx) + + should_transform = True + for leaf in (LL[string_idx - 1], LL[rpar_idx]): + if line.comments_after(leaf): + # Should not strip parentheses which have comments attached + # to them. + should_transform = False + break + if should_transform: + string_and_rpar_indices.extend((string_idx, rpar_idx)) + + if string_and_rpar_indices: + yield Ok(self._transform_to_new_line(line, string_and_rpar_indices)) + else: + yield Err( + CannotTransform("All string groups have comments attached to them.") + ) + + def _transform_to_new_line( + self, line: Line, string_and_rpar_indices: list[int] + ) -> Line: + LL = line.leaves + + new_line = line.clone() + new_line.comments = line.comments.copy() + + previous_idx = -1 + # We need to sort the indices, since string_idx and its matching + # rpar_idx may not come in order, e.g. in + # `("outer" % ("inner".join(items)))`, the "inner" string's + # string_idx is smaller than "outer" string's rpar_idx. + for idx in sorted(string_and_rpar_indices): + leaf = LL[idx] + lpar_or_rpar_idx = idx - 1 if leaf.type == token.STRING else idx + append_leaves(new_line, line, LL[previous_idx + 1 : lpar_or_rpar_idx]) + if leaf.type == token.STRING: + string_leaf = Leaf(token.STRING, LL[idx].value) + LL[lpar_or_rpar_idx].remove() # Remove lpar. + replace_child(LL[idx], string_leaf) + new_line.append(string_leaf) + # replace comments + old_comments = new_line.comments.pop(id(LL[idx]), []) + new_line.comments.setdefault(id(string_leaf), []).extend(old_comments) + else: + LL[lpar_or_rpar_idx].remove() # This is a rpar. + + previous_idx = idx + + # Append the leaves after the last idx: + append_leaves(new_line, line, LL[idx + 1 :]) + + return new_line + + +class BaseStringSplitter(StringTransformer): + """ + Abstract class for StringTransformers which transform a Line's strings by splitting + them or placing them on their own lines where necessary to avoid going over + the configured line length. + + Requirements: + * The target string value is responsible for the line going over the + line length limit. It follows that after all of black's other line + split methods have been exhausted, this line (or one of the resulting + lines after all line splits are performed) would still be over the + line_length limit unless we split this string. + AND + + * The target string is NOT a "pointless" string (i.e. a string that has + no parent or siblings). + AND + + * The target string is not followed by an inline comment that appears + to be a pragma. + AND + + * The target string is not a multiline (i.e. triple-quote) string. + """ + + STRING_OPERATORS: Final = [ + token.EQEQUAL, + token.GREATER, + token.GREATEREQUAL, + token.LESS, + token.LESSEQUAL, + token.NOTEQUAL, + token.PERCENT, + token.PLUS, + token.STAR, + ] + + @abstractmethod + def do_splitter_match(self, line: Line) -> TMatchResult: + """ + BaseStringSplitter asks its clients to override this method instead of + `StringTransformer.do_match(...)`. + + Follows the same protocol as `StringTransformer.do_match(...)`. + + Refer to `help(StringTransformer.do_match)` for more information. + """ + + def do_match(self, line: Line) -> TMatchResult: + match_result = self.do_splitter_match(line) + if isinstance(match_result, Err): + return match_result + + string_indices = match_result.ok() + assert len(string_indices) == 1, ( + f"{self.__class__.__name__} should only find one match at a time, found" + f" {len(string_indices)}" + ) + string_idx = string_indices[0] + vresult = self._validate(line, string_idx) + if isinstance(vresult, Err): + return vresult + + return match_result + + def _validate(self, line: Line, string_idx: int) -> TResult[None]: + """ + Checks that @line meets all of the requirements listed in this classes' + docstring. Refer to `help(BaseStringSplitter)` for a detailed + description of those requirements. + + Returns: + * Ok(None), if ALL of the requirements are met. + OR + * Err(CannotTransform), if ANY of the requirements are NOT met. + """ + LL = line.leaves + + string_leaf = LL[string_idx] + + max_string_length = self._get_max_string_length(line, string_idx) + if len(string_leaf.value) <= max_string_length: + return TErr( + "The string itself is not what is causing this line to be too long." + ) + + if not string_leaf.parent or [L.type for L in string_leaf.parent.children] == [ + token.STRING, + token.NEWLINE, + ]: + return TErr( + f"This string ({string_leaf.value}) appears to be pointless (i.e. has" + " no parent)." + ) + + if id(line.leaves[string_idx]) in line.comments and contains_pragma_comment( + line.comments[id(line.leaves[string_idx])] + ): + return TErr( + "Line appears to end with an inline pragma comment. Splitting the line" + " could modify the pragma's behavior." + ) + + if has_triple_quotes(string_leaf.value): + return TErr("We cannot split multiline strings.") + + return Ok(None) + + def _get_max_string_length(self, line: Line, string_idx: int) -> int: + """ + Calculates the max string length used when attempting to determine + whether or not the target string is responsible for causing the line to + go over the line length limit. + + WARNING: This method is tightly coupled to both StringSplitter and + (especially) StringParenWrapper. There is probably a better way to + accomplish what is being done here. + + Returns: + max_string_length: such that `line.leaves[string_idx].value > + max_string_length` implies that the target string IS responsible + for causing this line to exceed the line length limit. + """ + LL = line.leaves + + is_valid_index = is_valid_index_factory(LL) + + # We use the shorthand "WMA4" in comments to abbreviate "We must + # account for". When giving examples, we use STRING to mean some/any + # valid string. + # + # Finally, we use the following convenience variables: + # + # P: The leaf that is before the target string leaf. + # N: The leaf that is after the target string leaf. + # NN: The leaf that is after N. + + # WMA4 the whitespace at the beginning of the line. + offset = line.depth * 4 + + if is_valid_index(string_idx - 1): + p_idx = string_idx - 1 + if ( + LL[string_idx - 1].type == token.LPAR + and LL[string_idx - 1].value == "" + and string_idx >= 2 + ): + # If the previous leaf is an empty LPAR placeholder, we should skip it. + p_idx -= 1 + + P = LL[p_idx] + if P.type in self.STRING_OPERATORS: + # WMA4 a space and a string operator (e.g. `+ STRING` or `== STRING`). + offset += len(str(P)) + 1 + + if P.type == token.COMMA: + # WMA4 a space, a comma, and a closing bracket [e.g. `), STRING`]. + offset += 3 + + if P.type in [token.COLON, token.EQUAL, token.PLUSEQUAL, token.NAME]: + # This conditional branch is meant to handle dictionary keys, + # variable assignments, 'return STRING' statement lines, and + # 'else STRING' ternary expression lines. + + # WMA4 a single space. + offset += 1 + + # WMA4 the lengths of any leaves that came before that space, + # but after any closing bracket before that space. + for leaf in reversed(LL[: p_idx + 1]): + offset += len(str(leaf)) + if leaf.type in CLOSING_BRACKETS: + break + + if is_valid_index(string_idx + 1): + N = LL[string_idx + 1] + if N.type == token.RPAR and N.value == "" and len(LL) > string_idx + 2: + # If the next leaf is an empty RPAR placeholder, we should skip it. + N = LL[string_idx + 2] + + if N.type == token.COMMA: + # WMA4 a single comma at the end of the string (e.g `STRING,`). + offset += 1 + + if is_valid_index(string_idx + 2): + NN = LL[string_idx + 2] + + if N.type == token.DOT and NN.type == token.NAME: + # This conditional branch is meant to handle method calls invoked + # off of a string literal up to and including the LPAR character. + + # WMA4 the '.' character. + offset += 1 + + if ( + is_valid_index(string_idx + 3) + and LL[string_idx + 3].type == token.LPAR + ): + # WMA4 the left parenthesis character. + offset += 1 + + # WMA4 the length of the method's name. + offset += len(NN.value) + + has_comments = False + for comment_leaf in line.comments_after(LL[string_idx]): + if not has_comments: + has_comments = True + # WMA4 two spaces before the '#' character. + offset += 2 + + # WMA4 the length of the inline comment. + offset += len(comment_leaf.value) + + max_string_length = count_chars_in_width(str(line), self.line_length - offset) + return max_string_length + + @staticmethod + def _prefer_paren_wrap_match(LL: list[Leaf]) -> int | None: + """ + Returns: + string_idx such that @LL[string_idx] is equal to our target (i.e. + matched) string, if this line matches the "prefer paren wrap" statement + requirements listed in the 'Requirements' section of the StringParenWrapper + class's docstring. + OR + None, otherwise. + """ + # The line must start with a string. + if LL[0].type != token.STRING: + return None + + matching_nodes = [ + syms.listmaker, + syms.dictsetmaker, + syms.testlist_gexp, + ] + # If the string is an immediate child of a list/set/tuple literal... + if ( + parent_type(LL[0]) in matching_nodes + or parent_type(LL[0].parent) in matching_nodes + ): + # And the string is surrounded by commas (or is the first/last child)... + prev_sibling = LL[0].prev_sibling + next_sibling = LL[0].next_sibling + if ( + not prev_sibling + and not next_sibling + and parent_type(LL[0]) == syms.atom + ): + # If it's an atom string, we need to check the parent atom's siblings. + parent = LL[0].parent + assert parent is not None # For type checkers. + prev_sibling = parent.prev_sibling + next_sibling = parent.next_sibling + if (not prev_sibling or prev_sibling.type == token.COMMA) and ( + not next_sibling or next_sibling.type == token.COMMA + ): + return 0 + + return None + + +def iter_fexpr_spans(s: str) -> Iterator[tuple[int, int]]: + """ + Yields spans corresponding to expressions in a given f-string. + Spans are half-open ranges (left inclusive, right exclusive). + Assumes the input string is a valid f-string, but will not crash if the input + string is invalid. + """ + stack: list[int] = [] # our curly paren stack + i = 0 + while i < len(s): + if s[i] == "{": + # if we're in a string part of the f-string, ignore escaped curly braces + if not stack and i + 1 < len(s) and s[i + 1] == "{": + i += 2 + continue + stack.append(i) + i += 1 + continue + + if s[i] == "}": + if not stack: + i += 1 + continue + j = stack.pop() + # we've made it back out of the expression! yield the span + if not stack: + yield (j, i + 1) + i += 1 + continue + + # if we're in an expression part of the f-string, fast-forward through strings + # note that backslashes are not legal in the expression portion of f-strings + if stack: + delim = None + if s[i : i + 3] in ("'''", '"""'): + delim = s[i : i + 3] + elif s[i] in ("'", '"'): + delim = s[i] + if delim: + i += len(delim) + while i < len(s) and s[i : i + len(delim)] != delim: + i += 1 + i += len(delim) + continue + i += 1 + + +def fstring_contains_expr(s: str) -> bool: + return any(iter_fexpr_spans(s)) + + +def _toggle_fexpr_quotes(fstring: str, old_quote: str) -> str: + """ + Toggles quotes used in f-string expressions that are `old_quote`. + + f-string expressions can't contain backslashes, so we need to toggle the + quotes if the f-string itself will end up using the same quote. We can + simply toggle without escaping because, quotes can't be reused in f-string + expressions. They will fail to parse. + + NOTE: If PEP 701 is accepted, above statement will no longer be true. + Though if quotes can be reused, we can simply reuse them without updates or + escaping, once Black figures out how to parse the new grammar. + """ + new_quote = "'" if old_quote == '"' else '"' + parts = [] + previous_index = 0 + for start, end in iter_fexpr_spans(fstring): + parts.append(fstring[previous_index:start]) + parts.append(fstring[start:end].replace(old_quote, new_quote)) + previous_index = end + parts.append(fstring[previous_index:]) + return "".join(parts) + + +class StringSplitter(BaseStringSplitter, CustomSplitMapMixin): + """ + StringTransformer that splits "atom" strings (i.e. strings which exist on + lines by themselves). + + Requirements: + * The line consists ONLY of a single string (possibly prefixed by a + string operator [e.g. '+' or '==']), MAYBE a string trailer, and MAYBE + a trailing comma. + AND + * All of the requirements listed in BaseStringSplitter's docstring. + + Transformations: + The string mentioned in the 'Requirements' section is split into as + many substrings as necessary to adhere to the configured line length. + + In the final set of substrings, no substring should be smaller than + MIN_SUBSTR_SIZE characters. + + The string will ONLY be split on spaces (i.e. each new substring should + start with a space). Note that the string will NOT be split on a space + which is escaped with a backslash. + + If the string is an f-string, it will NOT be split in the middle of an + f-expression (e.g. in f"FooBar: {foo() if x else bar()}", {foo() if x + else bar()} is an f-expression). + + If the string that is being split has an associated set of custom split + records and those custom splits will NOT result in any line going over + the configured line length, those custom splits are used. Otherwise the + string is split as late as possible (from left-to-right) while still + adhering to the transformation rules listed above. + + Collaborations: + StringSplitter relies on StringMerger to construct the appropriate + CustomSplit objects and add them to the custom split map. + """ + + MIN_SUBSTR_SIZE: Final = 6 + + def do_splitter_match(self, line: Line) -> TMatchResult: + LL = line.leaves + + if self._prefer_paren_wrap_match(LL) is not None: + return TErr("Line needs to be wrapped in parens first.") + + # If the line is just STRING + COMMA (a one-item tuple) and not inside + # brackets, we need to defer to StringParenWrapper to wrap it first. + # Otherwise, splitting the string would create multiple expressions where + # only the last has the comma, breaking AST equivalence. See issue #4912. + if ( + not line.inside_brackets + and len(LL) == 2 + and LL[0].type == token.STRING + and LL[1].type == token.COMMA + ): + return TErr( + "Line with trailing comma tuple needs to be wrapped in parens first." + ) + + is_valid_index = is_valid_index_factory(LL) + + idx = 0 + + # The first two leaves MAY be the 'not in' keywords... + if ( + is_valid_index(idx) + and is_valid_index(idx + 1) + and [LL[idx].type, LL[idx + 1].type] == [token.NAME, token.NAME] + and str(LL[idx]) + str(LL[idx + 1]) == "not in" + ): + idx += 2 + # Else the first leaf MAY be a string operator symbol or the 'in' keyword... + elif is_valid_index(idx) and ( + LL[idx].type in self.STRING_OPERATORS + or LL[idx].type == token.NAME + and str(LL[idx]) == "in" + ): + idx += 1 + + # The next/first leaf MAY be an empty LPAR... + if is_valid_index(idx) and is_empty_lpar(LL[idx]): + idx += 1 + + # The next/first leaf MUST be a string... + if not is_valid_index(idx) or LL[idx].type != token.STRING: + return TErr("Line does not start with a string.") + + string_idx = idx + + # Skip the string trailer, if one exists. + string_parser = StringParser() + idx = string_parser.parse(LL, string_idx) + + # That string MAY be followed by an empty RPAR... + if is_valid_index(idx) and is_empty_rpar(LL[idx]): + idx += 1 + + # That string / empty RPAR leaf MAY be followed by a comma... + if is_valid_index(idx) and LL[idx].type == token.COMMA: + idx += 1 + + # But no more leaves are allowed... + if is_valid_index(idx): + return TErr("This line does not end with a string.") + + return Ok([string_idx]) + + def do_transform( + self, line: Line, string_indices: list[int] + ) -> Iterator[TResult[Line]]: + LL = line.leaves + assert len(string_indices) == 1, ( + f"{self.__class__.__name__} should only find one match at a time, found" + f" {len(string_indices)}" + ) + string_idx = string_indices[0] + + QUOTE = LL[string_idx].value[-1] + + is_valid_index = is_valid_index_factory(LL) + insert_str_child = insert_str_child_factory(LL[string_idx]) + + prefix = get_string_prefix(LL[string_idx].value).lower() + + # We MAY choose to drop the 'f' prefix from substrings that don't + # contain any f-expressions, but ONLY if the original f-string + # contains at least one f-expression. Otherwise, we will alter the AST + # of the program. + drop_pointless_f_prefix = ("f" in prefix) and fstring_contains_expr( + LL[string_idx].value + ) + + first_string_line = True + + string_op_leaves = self._get_string_operator_leaves(LL) + string_op_leaves_length = ( + sum(len(str(prefix_leaf)) for prefix_leaf in string_op_leaves) + 1 + if string_op_leaves + else 0 + ) + + def maybe_append_string_operators(new_line: Line) -> None: + """ + Side Effects: + If @line starts with a string operator and this is the first + line we are constructing, this function appends the string + operator to @new_line and replaces the old string operator leaf + in the node structure. Otherwise this function does nothing. + """ + maybe_prefix_leaves = string_op_leaves if first_string_line else [] + for i, prefix_leaf in enumerate(maybe_prefix_leaves): + replace_child(LL[i], prefix_leaf) + new_line.append(prefix_leaf) + + ends_with_comma = ( + is_valid_index(string_idx + 1) and LL[string_idx + 1].type == token.COMMA + ) + + def max_last_string_column() -> int: + """ + Returns: + The max allowed width of the string value used for the last + line we will construct. Note that this value means the width + rather than the number of characters (e.g., many East Asian + characters expand to two columns). + """ + result = self.line_length + result -= line.depth * 4 + result -= 1 if ends_with_comma else 0 + result -= string_op_leaves_length + return result + + # --- Calculate Max Break Width (for string value) + # We start with the line length limit + max_break_width = self.line_length + # The last index of a string of length N is N-1. + max_break_width -= 1 + # Leading whitespace is not present in the string value (e.g. Leaf.value). + max_break_width -= line.depth * 4 + if max_break_width < 0: + yield TErr( + f"Unable to split {LL[string_idx].value} at such high of a line depth:" + f" {line.depth}" + ) + return + + # Check if StringMerger registered any custom splits. + custom_splits = self.pop_custom_splits(LL[string_idx].value) + # We use them ONLY if none of them would produce lines that exceed the + # line limit. + use_custom_breakpoints = bool( + custom_splits + and all(csplit.break_idx <= max_break_width for csplit in custom_splits) + ) + + # Temporary storage for the remaining chunk of the string line that + # can't fit onto the line currently being constructed. + rest_value = LL[string_idx].value + + # Each substring is a suffix of this value (plus the prefix and quote), + # so a missing "\N" here means no substring can hold a named escape and + # the per-substring scan for them can be skipped entirely. + has_named_escape = "\\N" in rest_value + + def more_splits_should_be_made() -> bool: + """ + Returns: + True iff `rest_value` (the remaining string value from the last + split), should be split again. + """ + if use_custom_breakpoints: + return len(custom_splits) > 1 + else: + return str_width(rest_value) > max_last_string_column() + + string_line_results: list[Ok[Line]] = [] + while more_splits_should_be_made(): + if use_custom_breakpoints: + # Custom User Split (manual) + csplit = custom_splits.pop(0) + break_idx = csplit.break_idx + else: + # Algorithmic Split (automatic) + max_bidx = ( + count_chars_in_width(rest_value, max_break_width) + - string_op_leaves_length + ) + maybe_break_idx = self._get_break_idx( + rest_value, max_bidx, has_named_escape + ) + if maybe_break_idx is None: + # If we are unable to algorithmically determine a good split + # and this string has custom splits registered to it, we + # fall back to using them--which means we have to start + # over from the beginning. + if custom_splits: + rest_value = LL[string_idx].value + string_line_results = [] + first_string_line = True + use_custom_breakpoints = True + continue + + # Otherwise, we stop splitting here. + break + + break_idx = maybe_break_idx + + # --- Construct `next_value` + next_value = rest_value[:break_idx] + QUOTE + + # HACK: The following 'if' statement is a hack to fix the custom + # breakpoint index in the case of either: (a) substrings that were + # f-strings but will have the 'f' prefix removed OR (b) substrings + # that were not f-strings but will now become f-strings because of + # redundant use of the 'f' prefix (i.e. none of the substrings + # contain f-expressions but one or more of them had the 'f' prefix + # anyway; in which case, we will prepend 'f' to _all_ substrings). + # + # There is probably a better way to accomplish what is being done + # here... + # + # If this substring is an f-string, we _could_ remove the 'f' + # prefix, and the current custom split did NOT originally use a + # prefix... + if ( + use_custom_breakpoints + and not csplit.has_prefix + and ( + # `next_value == prefix + QUOTE` happens when the custom + # split is an empty string. + next_value == prefix + QUOTE + or next_value != self._normalize_f_string(next_value, prefix) + ) + ): + # Then `csplit.break_idx` will be off by one after removing + # the 'f' prefix. + break_idx += 1 + next_value = rest_value[:break_idx] + QUOTE + + if drop_pointless_f_prefix: + next_value = self._normalize_f_string(next_value, prefix) + + # --- Construct `next_leaf` + next_leaf = Leaf(token.STRING, next_value) + insert_str_child(next_leaf) + self._maybe_normalize_string_quotes(next_leaf) + + # --- Construct `next_line` + next_line = line.clone() + maybe_append_string_operators(next_line) + next_line.append(next_leaf) + string_line_results.append(Ok(next_line)) + + rest_value = prefix + QUOTE + rest_value[break_idx:] + first_string_line = False + + yield from string_line_results + + if drop_pointless_f_prefix: + rest_value = self._normalize_f_string(rest_value, prefix) + + rest_leaf = Leaf(token.STRING, rest_value) + insert_str_child(rest_leaf) + + # NOTE: I could not find a test case that verifies that the following + # line is actually necessary, but it seems to be. Otherwise we risk + # not normalizing the last substring, right? + self._maybe_normalize_string_quotes(rest_leaf) + + last_line = line.clone() + maybe_append_string_operators(last_line) + + # If there are any leaves to the right of the target string... + if is_valid_index(string_idx + 1): + # We use `temp_value` here to determine how long the last line + # would be if we were to append all the leaves to the right of the + # target string to the last string line. + temp_value = rest_value + for leaf in LL[string_idx + 1 :]: + temp_value += str(leaf) + if leaf.type == token.LPAR: + break + + # Try to fit them all on the same line with the last substring... + if ( + str_width(temp_value) <= max_last_string_column() + or LL[string_idx + 1].type == token.COMMA + ): + last_line.append(rest_leaf) + append_leaves(last_line, line, LL[string_idx + 1 :]) + yield Ok(last_line) + # Otherwise, place the last substring on one line and everything + # else on a line below that... + else: + last_line.append(rest_leaf) + yield Ok(last_line) + + non_string_line = line.clone() + append_leaves(non_string_line, line, LL[string_idx + 1 :]) + yield Ok(non_string_line) + # Else the target string was the last leaf... + else: + last_line.append(rest_leaf) + last_line.comments = line.comments.copy() + yield Ok(last_line) + + def _iter_nameescape_slices(self, string: str) -> Iterator[tuple[Index, Index]]: + r""" + Yields: + All ranges of @string which, if @string were to be split there, + would result in the splitting of an \N{...} expression (which is NOT + allowed). + """ + # True - the previous backslash was unescaped + # False - the previous backslash was escaped *or* there was no backslash + previous_was_unescaped_backslash = False + it = iter(enumerate(string)) + for idx, c in it: + if c == "\\": + previous_was_unescaped_backslash = not previous_was_unescaped_backslash + continue + if not previous_was_unescaped_backslash or c != "N": + previous_was_unescaped_backslash = False + continue + previous_was_unescaped_backslash = False + + begin = idx - 1 # the position of backslash before \N{...} + for idx, c in it: + if c == "}": + end = idx + break + else: + # malformed nameescape expression? + # should have been detected by AST parsing earlier... + raise RuntimeError(f"{self.__class__.__name__} LOGIC ERROR!") + yield begin, end + + def _iter_fexpr_slices(self, string: str) -> Iterator[tuple[Index, Index]]: + """ + Yields: + All ranges of @string which, if @string were to be split there, + would result in the splitting of an f-expression (which is NOT + allowed). + """ + if "f" not in get_string_prefix(string).lower(): + return + yield from iter_fexpr_spans(string) + + def _get_illegal_split_indices( + self, string: str, has_named_escape: bool = True + ) -> set[Index]: + illegal_indices: set[Index] = set() + iterators = [self._iter_fexpr_slices(string)] + # Scanning for \N{...} ranges walks the whole string, so skip it when the + # caller already knows the string cannot contain a named escape. + if has_named_escape: + iterators.append(self._iter_nameescape_slices(string)) + for it in iterators: + for begin, end in it: + illegal_indices.update(range(begin, end)) + return illegal_indices + + def _get_break_idx( + self, string: str, max_break_idx: int, has_named_escape: bool = True + ) -> int | None: + """ + This method contains the algorithm that StringSplitter uses to + determine which character to split each string at. + + Args: + @string: The substring that we are attempting to split. + @max_break_idx: The ideal break index. We will return this value if it + meets all the necessary conditions. In the likely event that it + doesn't we will try to find the closest index BELOW @max_break_idx + that does. If that fails, we will expand our search by also + considering all valid indices ABOVE @max_break_idx. + @has_named_escape: Whether the original string can contain a named + escape. False lets us skip the per-substring scan for them. + + Pre-Conditions: + * assert_is_leaf_string(@string) + * 0 <= @max_break_idx < len(@string) + + Returns: + break_idx, if an index is able to be found that meets all of the + conditions listed in the 'Transformations' section of this classes' + docstring. + OR + None, otherwise. + """ + is_valid_index = is_valid_index_factory(string) + + assert is_valid_index(max_break_idx) + assert_is_leaf_string(string) + + _illegal_split_indices = self._get_illegal_split_indices( + string, has_named_escape + ) + + def breaks_unsplittable_expression(i: Index) -> bool: + """ + Returns: + True iff returning @i would result in the splitting of an + unsplittable expression (which is NOT allowed). + """ + return i in _illegal_split_indices + + def passes_all_checks(i: Index) -> bool: + """ + Returns: + True iff ALL of the conditions listed in the 'Transformations' + section of this classes' docstring would be met by returning @i. + """ + is_space = string[i] == " " + is_split_safe = is_valid_index(i - 1) and string[i - 1] in SPLIT_SAFE_CHARS + + is_not_escaped = True + j = i - 1 + while is_valid_index(j) and string[j] == "\\": + is_not_escaped = not is_not_escaped + j -= 1 + + is_big_enough = ( + len(string) - i >= self.MIN_SUBSTR_SIZE and i >= self.MIN_SUBSTR_SIZE + ) + return ( + (is_space or is_split_safe) + and is_not_escaped + and is_big_enough + and not breaks_unsplittable_expression(i) + ) + + # First, we check all indices BELOW @max_break_idx. + break_idx = max_break_idx + while is_valid_index(break_idx - 1) and not passes_all_checks(break_idx): + break_idx -= 1 + + if not passes_all_checks(break_idx): + # If that fails, we check all indices ABOVE @max_break_idx. + # + # If we are able to find a valid index here, the next line is going + # to be longer than the specified line length, but it's probably + # better than doing nothing at all. + break_idx = max_break_idx + 1 + while is_valid_index(break_idx + 1) and not passes_all_checks(break_idx): + break_idx += 1 + + if not is_valid_index(break_idx) or not passes_all_checks(break_idx): + return None + + return break_idx + + def _maybe_normalize_string_quotes(self, leaf: Leaf) -> None: + if self.normalize_strings: + leaf.value = normalize_string_quotes(leaf.value) + + def _normalize_f_string(self, string: str, prefix: str) -> str: + """ + Pre-Conditions: + * assert_is_leaf_string(@string) + + Returns: + * If @string is an f-string that contains no f-expressions, we + return a string identical to @string except that the 'f' prefix + has been stripped and all double braces (i.e. '{{' or '}}') have + been normalized (i.e. turned into '{' or '}'). + OR + * Otherwise, we return @string. + """ + assert_is_leaf_string(string) + + if "f" in prefix and not fstring_contains_expr(string): + new_prefix = prefix.replace("f", "") + + temp = string[len(prefix) :] + temp = re.sub(r"\{\{", "{", temp) + temp = re.sub(r"\}\}", "}", temp) + new_string = temp + + return f"{new_prefix}{new_string}" + else: + return string + + def _get_string_operator_leaves(self, leaves: Iterable[Leaf]) -> list[Leaf]: + LL = list(leaves) + + string_op_leaves = [] + i = 0 + while LL[i].type in self.STRING_OPERATORS + [token.NAME]: + prefix_leaf = Leaf(LL[i].type, str(LL[i]).strip()) + string_op_leaves.append(prefix_leaf) + i += 1 + return string_op_leaves + + +class StringParenWrapper(BaseStringSplitter, CustomSplitMapMixin): + """ + StringTransformer that wraps strings in parens and then splits at the LPAR. + + Requirements: + All of the requirements listed in BaseStringSplitter's docstring in + addition to the requirements listed below: + + * The line is a return/yield statement, which returns/yields a string. + OR + * The line is part of a ternary expression (e.g. `x = y if cond else + z`) such that the line starts with `else `, where is + some string. + OR + * The line is an assert statement, which ends with a string. + OR + * The line is an assignment statement (e.g. `x = ` or `x += + `) such that the variable is being assigned the value of some + string. + OR + * The line is a dictionary key assignment where some valid key is being + assigned the value of some string. + OR + * The line is an lambda expression and the value is a string. + OR + * The line starts with an "atom" string that prefers to be wrapped in + parens. It's preferred to be wrapped when it's is an immediate child of + a list/set/tuple literal, AND the string is surrounded by commas (or is + the first/last child). + + Transformations: + The chosen string is wrapped in parentheses and then split at the LPAR. + + We then have one line which ends with an LPAR and another line that + starts with the chosen string. The latter line is then split again at + the RPAR. This results in the RPAR (and possibly a trailing comma) + being placed on its own line. + + NOTE: If any leaves exist to the right of the chosen string (except + for a trailing comma, which would be placed after the RPAR), those + leaves are placed inside the parentheses. In effect, the chosen + string is not necessarily being "wrapped" by parentheses. We can, + however, count on the LPAR being placed directly before the chosen + string. + + In other words, StringParenWrapper creates "atom" strings. These + can then be split again by StringSplitter, if necessary. + + Collaborations: + In the event that a string line split by StringParenWrapper is + changed such that it no longer needs to be given its own line, + StringParenWrapper relies on StringParenStripper to clean up the + parentheses it created. + + For "atom" strings that prefers to be wrapped in parens, it requires + StringSplitter to hold the split until the string is wrapped in parens. + """ + + def do_splitter_match(self, line: Line) -> TMatchResult: + LL = line.leaves + + if line.leaves[-1].type in OPENING_BRACKETS: + return TErr( + "Cannot wrap parens around a line that ends in an opening bracket." + ) + + string_idx = ( + self._return_match(LL) + or self._else_match(LL) + or self._assert_match(LL) + or self._assign_match(LL) + or self._dict_or_lambda_match(LL) + ) + + if string_idx is None: + string_idx = self._trailing_comma_tuple_match(line) + + if string_idx is None: + string_idx = self._prefer_paren_wrap_match(LL) + + if string_idx is not None: + string_value = line.leaves[string_idx].value + # If the string has neither spaces nor East Asian stops... + if not any( + char == " " or char in SPLIT_SAFE_CHARS for char in string_value + ): + # And will still violate the line length limit when split... + max_string_width = self.line_length - ((line.depth + 1) * 4) + if str_width(string_value) > max_string_width: + # And has no associated custom splits... + if not self.has_custom_splits(string_value): + # Then we should NOT put this string on its own line. + return TErr( + "We do not wrap long strings in parentheses when the" + " resultant line would still be over the specified line" + " length and can't be split further by StringSplitter." + ) + return Ok([string_idx]) + + return TErr("This line does not contain any non-atomic strings.") + + @staticmethod + def _return_match(LL: list[Leaf]) -> int | None: + """ + Returns: + string_idx such that @LL[string_idx] is equal to our target (i.e. + matched) string, if this line matches the return/yield statement + requirements listed in the 'Requirements' section of this classes' + docstring. + OR + None, otherwise. + """ + # If this line is a part of a return/yield statement and the first leaf + # contains either the "return" or "yield" keywords... + if parent_type(LL[0]) in [syms.return_stmt, syms.yield_expr] and LL[ + 0 + ].value in ["return", "yield"]: + is_valid_index = is_valid_index_factory(LL) + + idx = 2 if is_valid_index(1) and is_empty_par(LL[1]) else 1 + # The next visible leaf MUST contain a string... + if is_valid_index(idx) and LL[idx].type == token.STRING: + return idx + + return None + + @staticmethod + def _else_match(LL: list[Leaf]) -> int | None: + """ + Returns: + string_idx such that @LL[string_idx] is equal to our target (i.e. + matched) string, if this line matches the ternary expression + requirements listed in the 'Requirements' section of this classes' + docstring. + OR + None, otherwise. + """ + # If this line is a part of a ternary expression and the first leaf + # contains the "else" keyword... + if ( + parent_type(LL[0]) == syms.test + and LL[0].type == token.NAME + and LL[0].value == "else" + ): + is_valid_index = is_valid_index_factory(LL) + + idx = 2 if is_valid_index(1) and is_empty_par(LL[1]) else 1 + # The next visible leaf MUST contain a string... + if is_valid_index(idx) and LL[idx].type == token.STRING: + return idx + + return None + + @staticmethod + def _assert_match(LL: list[Leaf]) -> int | None: + """ + Returns: + string_idx such that @LL[string_idx] is equal to our target (i.e. + matched) string, if this line matches the assert statement + requirements listed in the 'Requirements' section of this classes' + docstring. + OR + None, otherwise. + """ + # If this line is a part of an assert statement and the first leaf + # contains the "assert" keyword... + if parent_type(LL[0]) == syms.assert_stmt and LL[0].value == "assert": + is_valid_index = is_valid_index_factory(LL) + + for i, leaf in enumerate(LL): + # We MUST find a comma... + if leaf.type == token.COMMA: + idx = i + 2 if is_empty_par(LL[i + 1]) else i + 1 + + # That comma MUST be followed by a string... + if is_valid_index(idx) and LL[idx].type == token.STRING: + string_idx = idx + + # Skip the string trailer, if one exists. + string_parser = StringParser() + idx = string_parser.parse(LL, string_idx) + + # But no more leaves are allowed... + if not is_valid_index(idx): + return string_idx + + return None + + @staticmethod + def _assign_match(LL: list[Leaf]) -> int | None: + """ + Returns: + string_idx such that @LL[string_idx] is equal to our target (i.e. + matched) string, if this line matches the assignment statement + requirements listed in the 'Requirements' section of this classes' + docstring. + OR + None, otherwise. + """ + # If this line is a part of an expression statement or is a function + # argument AND the first leaf contains a variable name... + if ( + parent_type(LL[0]) in [syms.expr_stmt, syms.argument, syms.power] + and LL[0].type == token.NAME + ): + is_valid_index = is_valid_index_factory(LL) + + for i, leaf in enumerate(LL): + # We MUST find either an '=' or '+=' symbol... + if leaf.type in [token.EQUAL, token.PLUSEQUAL]: + idx = i + 2 if is_empty_par(LL[i + 1]) else i + 1 + + # That symbol MUST be followed by a string... + if is_valid_index(idx) and LL[idx].type == token.STRING: + string_idx = idx + + # Skip the string trailer, if one exists. + string_parser = StringParser() + idx = string_parser.parse(LL, string_idx) + + # The next leaf MAY be a comma iff this line is a part + # of a function argument... + if ( + parent_type(LL[0]) == syms.argument + and is_valid_index(idx) + and LL[idx].type == token.COMMA + ): + idx += 1 + + # But no more leaves are allowed... + if not is_valid_index(idx): + return string_idx + + return None + + @staticmethod + def _dict_or_lambda_match(LL: list[Leaf]) -> int | None: + """ + Returns: + string_idx such that @LL[string_idx] is equal to our target (i.e. + matched) string, if this line matches the dictionary key assignment + statement or lambda expression requirements listed in the + 'Requirements' section of this classes' docstring. + OR + None, otherwise. + """ + # If this line is a part of a dictionary key assignment or lambda expression... + parent_types = [parent_type(LL[0]), parent_type(LL[0].parent)] + if syms.dictsetmaker in parent_types or syms.lambdef in parent_types: + is_valid_index = is_valid_index_factory(LL) + + for i, leaf in enumerate(LL): + # We MUST find a colon, it can either be dict's or lambda's colon... + if leaf.type == token.COLON and i < len(LL) - 1: + idx = i + 2 if is_empty_par(LL[i + 1]) else i + 1 + + # That colon MUST be followed by a string... + if is_valid_index(idx) and LL[idx].type == token.STRING: + string_idx = idx + + # Skip the string trailer, if one exists. + string_parser = StringParser() + idx = string_parser.parse(LL, string_idx) + + # That string MAY be followed by a comma... + if is_valid_index(idx) and LL[idx].type == token.COMMA: + idx += 1 + + # But no more leaves are allowed... + if not is_valid_index(idx): + return string_idx + + return None + + @staticmethod + def _trailing_comma_tuple_match(line: Line) -> int | None: + """ + Returns: + string_idx such that @line.leaves[string_idx] is equal to our target + (i.e. matched) string, if the line is a bare trailing comma tuple + (STRING + COMMA) not inside brackets. + OR + None, otherwise. + + This handles the case from issue #4912 where a long string with a + trailing comma (making it a one-item tuple) needs to be wrapped in + parentheses before splitting to preserve AST equivalence. + """ + LL = line.leaves + # Match: STRING followed by COMMA, not inside brackets + if ( + not line.inside_brackets + and len(LL) == 2 + and LL[0].type == token.STRING + and LL[1].type == token.COMMA + ): + return 0 + + return None + + def do_transform( + self, line: Line, string_indices: list[int] + ) -> Iterator[TResult[Line]]: + LL = line.leaves + assert len(string_indices) == 1, ( + f"{self.__class__.__name__} should only find one match at a time, found" + f" {len(string_indices)}" + ) + string_idx = string_indices[0] + + is_valid_index = is_valid_index_factory(LL) + insert_str_child = insert_str_child_factory(LL[string_idx]) + + comma_idx = -1 + ends_with_comma = False + if LL[comma_idx].type == token.COMMA: + ends_with_comma = True + + leaves_to_steal_comments_from = [LL[string_idx]] + if ends_with_comma: + leaves_to_steal_comments_from.append(LL[comma_idx]) + + # --- First Line + first_line = line.clone() + left_leaves = LL[:string_idx] + + # We have to remember to account for (possibly invisible) LPAR and RPAR + # leaves that already wrapped the target string. If these leaves do + # exist, we will replace them with our own LPAR and RPAR leaves. + old_parens_exist = False + if left_leaves and left_leaves[-1].type == token.LPAR: + old_parens_exist = True + leaves_to_steal_comments_from.append(left_leaves[-1]) + left_leaves.pop() + + append_leaves(first_line, line, left_leaves) + + lpar_leaf = Leaf(token.LPAR, "(") + if old_parens_exist: + replace_child(LL[string_idx - 1], lpar_leaf) + else: + insert_str_child(lpar_leaf) + first_line.append(lpar_leaf) + + # We throw inline comments that were originally to the right of the + # target string to the top line. They will now be shown to the right of + # the LPAR. + for leaf in leaves_to_steal_comments_from: + for comment_leaf in line.comments_after(leaf): + first_line.append(comment_leaf, preformatted=True) + + yield Ok(first_line) + + # --- Middle (String) Line + # We only need to yield one (possibly too long) string line, since the + # `StringSplitter` will break it down further if necessary. + string_value = LL[string_idx].value + string_line = Line( + mode=line.mode, + depth=line.depth + 1, + inside_brackets=True, + should_split_rhs=line.should_split_rhs, + magic_trailing_comma=line.magic_trailing_comma, + ) + string_leaf = Leaf(token.STRING, string_value) + insert_str_child(string_leaf) + string_line.append(string_leaf) + + old_rpar_leaf = None + if is_valid_index(string_idx + 1): + right_leaves = LL[string_idx + 1 :] + if ends_with_comma: + right_leaves.pop() + + if old_parens_exist: + assert right_leaves and right_leaves[-1].type == token.RPAR, ( + "Apparently, old parentheses do NOT exist?!" + f" (left_leaves={left_leaves}, right_leaves={right_leaves})" + ) + old_rpar_leaf = right_leaves.pop() + elif right_leaves and right_leaves[-1].type == token.RPAR: + # Special case for lambda expressions as dict's value, e.g.: + # my_dict = { + # "key": lambda x: f"formatted: {x}", + # } + # After wrapping the dict's value with parentheses, the string is + # followed by a RPAR but its opening bracket is lambda's, not + # the string's: + # "key": (lambda x: f"formatted: {x}"), + opening_bracket = right_leaves[-1].opening_bracket + if opening_bracket is not None and opening_bracket in left_leaves: + index = left_leaves.index(opening_bracket) + if ( + 0 < index < len(left_leaves) - 1 + and left_leaves[index - 1].type == token.COLON + and left_leaves[index + 1].value == "lambda" + ): + right_leaves.pop() + + append_leaves(string_line, line, right_leaves) + + yield Ok(string_line) + + # --- Last Line + last_line = line.clone() + last_line.bracket_tracker = first_line.bracket_tracker + + new_rpar_leaf = Leaf(token.RPAR, ")") + if old_rpar_leaf is not None: + replace_child(old_rpar_leaf, new_rpar_leaf) + else: + insert_str_child(new_rpar_leaf) + last_line.append(new_rpar_leaf) + + # If the target string ended with a comma, we place this comma to the + # right of the RPAR on the last line. + if ends_with_comma: + comma_leaf = Leaf(token.COMMA, ",") + replace_child(LL[comma_idx], comma_leaf) + last_line.append(comma_leaf) + + yield Ok(last_line) + + +class StringParser: + """ + A state machine that aids in parsing a string's "trailer", which can be + either non-existent, an old-style formatting sequence (e.g. `% varX` or `% + (varX, varY)`), or a method-call / attribute access (e.g. `.format(varX, + varY)`). + + NOTE: A new StringParser object MUST be instantiated for each string + trailer we need to parse. + + Examples: + We shall assume that `line` equals the `Line` object that corresponds + to the following line of python code: + ``` + x = "Some {}.".format("String") + some_other_string + ``` + + Furthermore, we will assume that `string_idx` is some index such that: + ``` + assert line.leaves[string_idx].value == "Some {}." + ``` + + The following code snippet then holds: + ``` + string_parser = StringParser() + idx = string_parser.parse(line.leaves, string_idx) + assert line.leaves[idx].type == token.PLUS + ``` + """ + + DEFAULT_TOKEN: Final = 20210605 + + # String Parser States + START: Final = 1 + DOT: Final = 2 + NAME: Final = 3 + PERCENT: Final = 4 + SINGLE_FMT_ARG: Final = 5 + LPAR: Final = 6 + RPAR: Final = 7 + DONE: Final = 8 + + # Lookup Table for Next State + _goto: Final[dict[tuple[ParserState, NodeType], ParserState]] = { + # A string trailer may start with '.' OR '%'. + (START, token.DOT): DOT, + (START, token.PERCENT): PERCENT, + (START, DEFAULT_TOKEN): DONE, + # A '.' MUST be followed by an attribute or method name. + (DOT, token.NAME): NAME, + # A method name MUST be followed by an '(', whereas an attribute name + # is the last symbol in the string trailer. + (NAME, token.LPAR): LPAR, + (NAME, DEFAULT_TOKEN): DONE, + # A '%' symbol can be followed by an '(' or a single argument (e.g. a + # string or variable name). + (PERCENT, token.LPAR): LPAR, + (PERCENT, DEFAULT_TOKEN): SINGLE_FMT_ARG, + # If a '%' symbol is followed by a single argument, that argument is + # the last leaf in the string trailer. + (SINGLE_FMT_ARG, DEFAULT_TOKEN): DONE, + # If present, a ')' symbol is the last symbol in a string trailer. + # (NOTE: LPARS and nested RPARS are not included in this lookup table, + # since they are treated as a special case by the parsing logic in this + # classes' implementation.) + (RPAR, DEFAULT_TOKEN): DONE, + } + + def __init__(self) -> None: + self._state = self.START + self._unmatched_lpars = 0 + + def parse(self, leaves: list[Leaf], string_idx: int) -> int: + """ + Pre-conditions: + * @leaves[@string_idx].type == token.STRING + + Returns: + The index directly after the last leaf which is a part of the string + trailer, if a "trailer" exists. + OR + @string_idx + 1, if no string "trailer" exists. + """ + assert leaves[string_idx].type == token.STRING + + idx = string_idx + 1 + while idx < len(leaves) and self._next_state(leaves[idx]): + idx += 1 + return idx + + def _next_state(self, leaf: Leaf) -> bool: + """ + Pre-conditions: + * On the first call to this function, @leaf MUST be the leaf that + was directly after the string leaf in question (e.g. if our target + string is `line.leaves[i]` then the first call to this method must + be `line.leaves[i + 1]`). + * On the next call to this function, the leaf parameter passed in + MUST be the leaf directly following @leaf. + + Returns: + True iff @leaf is a part of the string's trailer. + """ + # We ignore empty LPAR or RPAR leaves. + if is_empty_par(leaf): + return True + + next_token = leaf.type + if next_token == token.LPAR: + self._unmatched_lpars += 1 + + current_state = self._state + + # The LPAR parser state is a special case. We will return True until we + # find the matching RPAR token. + if current_state == self.LPAR: + if next_token == token.RPAR: + self._unmatched_lpars -= 1 + if self._unmatched_lpars == 0: + self._state = self.RPAR + # Otherwise, we use a lookup table to determine the next state. + else: + # If the lookup table matches the current state to the next + # token, we use the lookup table. + if (current_state, next_token) in self._goto: + self._state = self._goto[current_state, next_token] + else: + # Otherwise, we check if a the current state was assigned a + # default. + if (current_state, self.DEFAULT_TOKEN) in self._goto: + self._state = self._goto[current_state, self.DEFAULT_TOKEN] + # If no default has been assigned, then this parser has a logic + # error. + else: + raise RuntimeError(f"{self.__class__.__name__} LOGIC ERROR!") + + if self._state == self.DONE: + return False + + return True + + +def insert_str_child_factory(string_leaf: Leaf) -> Callable[[LN], None]: + """ + Factory for a convenience function that is used to orphan @string_leaf + and then insert multiple new leaves into the same part of the node + structure that @string_leaf had originally occupied. + + Examples: + Let `string_leaf = Leaf(token.STRING, '"foo"')` and `N = + string_leaf.parent`. Assume the node `N` has the following + original structure: + + Node( + expr_stmt, [ + Leaf(NAME, 'x'), + Leaf(EQUAL, '='), + Leaf(STRING, '"foo"'), + ] + ) + + We then run the code snippet shown below. + ``` + insert_str_child = insert_str_child_factory(string_leaf) + + lpar = Leaf(token.LPAR, '(') + insert_str_child(lpar) + + bar = Leaf(token.STRING, '"bar"') + insert_str_child(bar) + + rpar = Leaf(token.RPAR, ')') + insert_str_child(rpar) + ``` + + After which point, it follows that `string_leaf.parent is None` and + the node `N` now has the following structure: + + Node( + expr_stmt, [ + Leaf(NAME, 'x'), + Leaf(EQUAL, '='), + Leaf(LPAR, '('), + Leaf(STRING, '"bar"'), + Leaf(RPAR, ')'), + ] + ) + """ + string_parent = string_leaf.parent + string_child_idx = string_leaf.remove() + + def insert_str_child(child: LN) -> None: + nonlocal string_child_idx + + assert string_parent is not None + assert string_child_idx is not None + + string_parent.insert_child(string_child_idx, child) + string_child_idx += 1 + + return insert_str_child + + +def is_valid_index_factory(seq: Sequence[Any]) -> Callable[[int], bool]: + """ + Examples: + ``` + my_list = [1, 2, 3] + + is_valid_index = is_valid_index_factory(my_list) + + assert is_valid_index(0) + assert is_valid_index(2) + + assert not is_valid_index(3) + assert not is_valid_index(-1) + ``` + """ + + def is_valid_index(idx: int) -> bool: + """ + Returns: + True iff @idx is positive AND seq[@idx] does NOT raise an + IndexError. + """ + return 0 <= idx < len(seq) + + return is_valid_index diff --git a/src/blackd/__init__.py b/src/blackd/__init__.py new file mode 100644 index 0000000..5df160b --- /dev/null +++ b/src/blackd/__init__.py @@ -0,0 +1,336 @@ +import asyncio +import logging +import os +from concurrent.futures import Executor, ProcessPoolExecutor +from datetime import datetime, timezone +from functools import cache, partial +from multiprocessing import freeze_support + +try: + from aiohttp import web + from multidict import MultiMapping + + from .middlewares import cors +except ImportError as ie: + raise ImportError( + f"aiohttp dependency is not installed: {ie}. " + + "Please re-install black with the '[d]' extra install " + + "to obtain aiohttp_cors: `pip install black[d]`" + ) from None + +import click + +import black +from _black_version import version as __version__ +from black.concurrency import maybe_use_uvloop + +# This is used internally by tests to shut down the server prematurely +_stop_signal = asyncio.Event() + +# Request headers +PROTOCOL_VERSION_HEADER = "X-Protocol-Version" +LINE_LENGTH_HEADER = "X-Line-Length" +PYTHON_VARIANT_HEADER = "X-Python-Variant" +SKIP_SOURCE_FIRST_LINE = "X-Skip-Source-First-Line" +SKIP_STRING_NORMALIZATION_HEADER = "X-Skip-String-Normalization" +SKIP_MAGIC_TRAILING_COMMA = "X-Skip-Magic-Trailing-Comma" +PREVIEW = "X-Preview" +UNSTABLE = "X-Unstable" +ENABLE_UNSTABLE_FEATURE = "X-Enable-Unstable-Feature" +FAST_OR_SAFE_HEADER = "X-Fast-Or-Safe" +DIFF_HEADER = "X-Diff" + +BLACK_HEADERS = [ + PROTOCOL_VERSION_HEADER, + LINE_LENGTH_HEADER, + PYTHON_VARIANT_HEADER, + SKIP_SOURCE_FIRST_LINE, + SKIP_STRING_NORMALIZATION_HEADER, + SKIP_MAGIC_TRAILING_COMMA, + PREVIEW, + UNSTABLE, + ENABLE_UNSTABLE_FEATURE, + FAST_OR_SAFE_HEADER, + DIFF_HEADER, +] + +# Response headers +BLACK_VERSION_HEADER = "X-Black-Version" +DEFAULT_MAX_BODY_SIZE = 5 * 1024 * 1024 +DEFAULT_WORKERS = os.cpu_count() or 1 + + +class HeaderError(Exception): + pass + + +class InvalidVariantHeader(Exception): + pass + + +@click.command(context_settings={"help_option_names": ["-h", "--help"]}) +@click.option( + "--bind-host", + type=str, + help="Address to bind the server to.", + default="localhost", + show_default=True, +) +@click.option( + "--bind-port", type=int, help="Port to listen on", default=45484, show_default=True +) +@click.option( + "--cors-allow-origin", + "cors_allow_origins", + multiple=True, + help="Origin allowed to access blackd over CORS. Can be passed multiple times.", +) +@click.option( + "--max-body-size", + type=click.IntRange(min=1), + default=DEFAULT_MAX_BODY_SIZE, + show_default=True, + help="Maximum request body size in bytes.", +) +@click.version_option(version=black.__version__) +def main( + bind_host: str, + bind_port: int, + cors_allow_origins: tuple[str, ...], + max_body_size: int, +) -> None: + logging.basicConfig(level=logging.INFO) + app = make_app(cors_allow_origins=cors_allow_origins, max_body_size=max_body_size) + ver = black.__version__ + black.out(f"blackd version {ver} listening on {bind_host} port {bind_port}") + loop = maybe_use_uvloop() + try: + web.run_app( + app, + host=bind_host, + port=bind_port, + handle_signals=True, + print=None, + loop=loop, + ) + finally: + if not loop.is_closed(): + loop.close() + + +@cache +def executor() -> Executor: + return ProcessPoolExecutor(max_workers=DEFAULT_WORKERS) + + +def make_app( + *, + cors_allow_origins: tuple[str, ...] = (), + max_body_size: int = DEFAULT_MAX_BODY_SIZE, +) -> web.Application: + app = web.Application( + client_max_size=max_body_size, + middlewares=[ + cors( + allow_headers=(*BLACK_HEADERS, "Content-Type"), + allow_origins=frozenset(cors_allow_origins), + expose_headers=(BLACK_VERSION_HEADER,), + ) + ], + ) + app.add_routes([ + web.post( + "/", + partial( + handle, + executor=executor(), + executor_semaphore=asyncio.BoundedSemaphore(DEFAULT_WORKERS), + ), + ) + ]) + return app + + +async def handle( + request: web.Request, + executor: Executor, + executor_semaphore: asyncio.BoundedSemaphore, +) -> web.Response: + headers = {BLACK_VERSION_HEADER: __version__} + try: + if request.headers.get(PROTOCOL_VERSION_HEADER, "1") != "1": + return web.Response( + status=501, text="This server only supports protocol version 1" + ) + + fast = False + if request.headers.get(FAST_OR_SAFE_HEADER, "safe") == "fast": + fast = True + try: + mode = parse_mode(request.headers) + except HeaderError as e: + return web.Response(status=400, text=e.args[0]) + req_bytes = await request.read() + charset = request.charset if request.charset is not None else "utf8" + req_str = req_bytes.decode(charset) + then = datetime.now(timezone.utc) + + header = "" + if mode.skip_source_first_line: + first_newline_position: int = req_str.find("\n") + 1 + header = req_str[:first_newline_position] + req_str = req_str[first_newline_position:] + + only_diff = bool(request.headers.get(DIFF_HEADER, False)) + formatted_str = await format_code( + req_str=req_str, + fast=fast, + mode=mode, + then=then, + only_diff=only_diff, + executor=executor, + executor_semaphore=executor_semaphore, + ) + + # Put the source first line back + req_str = header + req_str + formatted_str = header + formatted_str + + return web.Response( + content_type=request.content_type, + charset=charset, + headers=headers, + text=formatted_str, + ) + except black.NothingChanged: + return web.Response(status=204, headers=headers) + except black.InvalidInput as e: + return web.Response(status=400, headers=headers, text=str(e)) + except black.SourceASTParseError as e: + return web.Response(status=400, headers=headers, text=str(e)) + except web.HTTPException: + raise + except Exception as e: + logging.exception("Exception during handling a request") + return web.Response(status=500, headers=headers, text=str(e)) + + +async def format_code( + *, + req_str: str, + fast: bool, + mode: black.FileMode, + then: datetime, + only_diff: bool, + executor: Executor, + executor_semaphore: asyncio.BoundedSemaphore, +) -> str: + async with executor_semaphore: + loop = asyncio.get_event_loop() + formatted_str = await loop.run_in_executor( + executor, partial(black.format_file_contents, req_str, fast=fast, mode=mode) + ) + + if not only_diff: + return formatted_str + + now = datetime.now(timezone.utc) + src_name = f"In\t{then}" + dst_name = f"Out\t{now}" + return await loop.run_in_executor( + executor, + partial(black.diff, req_str, formatted_str, src_name, dst_name), + ) + + +def parse_mode(headers: MultiMapping[str]) -> black.Mode: + try: + line_length = int(headers.get(LINE_LENGTH_HEADER, black.DEFAULT_LINE_LENGTH)) + except ValueError: + raise HeaderError("Invalid line length header value") from None + + if PYTHON_VARIANT_HEADER in headers: + value = headers[PYTHON_VARIANT_HEADER] + try: + pyi, versions = parse_python_variant_header(value) + except InvalidVariantHeader as e: + raise HeaderError( + f"Invalid value for {PYTHON_VARIANT_HEADER}: {e.args[0]}", + ) from None + else: + pyi = False + versions = set() + + skip_string_normalization = bool( + headers.get(SKIP_STRING_NORMALIZATION_HEADER, False) + ) + skip_magic_trailing_comma = bool(headers.get(SKIP_MAGIC_TRAILING_COMMA, False)) + skip_source_first_line = bool(headers.get(SKIP_SOURCE_FIRST_LINE, False)) + + preview = bool(headers.get(PREVIEW, False)) + unstable = bool(headers.get(UNSTABLE, False)) + enable_features: set[black.Preview] = set() + enable_unstable_features = headers.get(ENABLE_UNSTABLE_FEATURE, "").split(",") + for piece in enable_unstable_features: + piece = piece.strip() + if piece: + try: + enable_features.add(black.Preview[piece]) + except KeyError: + raise HeaderError( + f"Invalid value for {ENABLE_UNSTABLE_FEATURE}: {piece}", + ) from None + + return black.FileMode( + target_versions=versions, + is_pyi=pyi, + line_length=line_length, + skip_source_first_line=skip_source_first_line, + string_normalization=not skip_string_normalization, + magic_trailing_comma=not skip_magic_trailing_comma, + preview=preview, + unstable=unstable, + enabled_features=enable_features, + ) + + +def parse_python_variant_header(value: str) -> tuple[bool, set[black.TargetVersion]]: + if value == "pyi": + return True, set() + else: + versions = set() + for version in value.split(","): + if version.startswith("py"): + version = version[len("py") :] + if "." in version: + major_str, *rest = version.split(".") + else: + major_str = version[0] + rest = [version[1:]] if len(version) > 1 else [] + try: + major = int(major_str) + if major not in (2, 3): + raise InvalidVariantHeader("major version must be 2 or 3") + if len(rest) > 0: + minor = int(rest[0]) + if major == 2: + raise InvalidVariantHeader("Python 2 is not supported") + else: + # Default to lowest supported minor version. + minor = 7 if major == 2 else 3 + version_str = f"PY{major}{minor}" + if major == 3 and not hasattr(black.TargetVersion, version_str): + raise InvalidVariantHeader(f"3.{minor} is not supported") + versions.add(black.TargetVersion[version_str]) + except (KeyError, ValueError): + raise InvalidVariantHeader("expected e.g. '3.7', 'py3.5'") from None + return False, versions + + +def patched_main() -> None: + freeze_support() + main() + + +if __name__ == "__main__": + patched_main() diff --git a/src/blackd/__main__.py b/src/blackd/__main__.py new file mode 100644 index 0000000..b5a4b13 --- /dev/null +++ b/src/blackd/__main__.py @@ -0,0 +1,3 @@ +import blackd + +blackd.patched_main() diff --git a/src/blackd/client.py b/src/blackd/client.py new file mode 100644 index 0000000..c36759a --- /dev/null +++ b/src/blackd/client.py @@ -0,0 +1,92 @@ +import aiohttp +from aiohttp.typedefs import StrOrURL + +import black + +_DEFAULT_HEADERS = {"Content-Type": "text/plain; charset=utf-8"} + + +class BlackDClient: + def __init__( + self, + url: StrOrURL = "http://localhost:9090", + line_length: int | None = None, + skip_source_first_line: bool = False, + skip_string_normalization: bool = False, + skip_magic_trailing_comma: bool = False, + preview: bool = False, + fast: bool = False, + python_variant: str | None = None, + diff: bool = False, + headers: dict[str, str] | None = None, + ): + """ + Initialize a BlackDClient object. + :param url: The URL of the BlackD server. + :param line_length: The maximum line length. + Corresponds to the ``--line-length`` CLI option. + :param skip_source_first_line: True to skip the first line of the source. + Corresponds to the ``--skip-source-first-line`` CLI option. + :param skip_string_normalization: True to skip string normalization. + Corresponds to the ``--skip-string-normalization`` CLI option. + :param skip_magic_trailing_comma: True to skip magic trailing comma. + Corresponds to the ``--skip-magic-trailing-comma`` CLI option. + :param preview: True to enable experimental preview mode. + Corresponds to the ``--preview`` CLI option. + :param fast: True to enable fast mode. + Corresponds to the ``--fast`` CLI option. + :param python_variant: The Python variant to use. + Corresponds to the ``--pyi`` CLI option if this is "pyi". + Otherwise, corresponds to the ``--target-version`` CLI option. + :param diff: True to enable diff mode. + Corresponds to the ``--diff`` CLI option. + :param headers: A dictionary of additional custom headers to send with + the request. + """ + self.url = url + self.headers = _DEFAULT_HEADERS.copy() + + if line_length is not None: + self.headers["X-Line-Length"] = str(line_length) + if skip_source_first_line: + self.headers["X-Skip-Source-First-Line"] = "yes" + if skip_string_normalization: + self.headers["X-Skip-String-Normalization"] = "yes" + if skip_magic_trailing_comma: + self.headers["X-Skip-Magic-Trailing-Comma"] = "yes" + if preview: + self.headers["X-Preview"] = "yes" + if fast: + self.headers["X-Fast-Or-Safe"] = "fast" + if python_variant is not None: + self.headers["X-Python-Variant"] = python_variant + if diff: + self.headers["X-Diff"] = "yes" + + if headers is not None: + self.headers.update(headers) + + async def format_code(self, unformatted_code: str) -> str: + async with aiohttp.ClientSession() as session: + async with session.post( + self.url, headers=self.headers, data=unformatted_code.encode("utf-8") + ) as response: + if response.status == 204: + # Input is already well-formatted + return unformatted_code + elif response.status == 200: + # Formatting was needed + return await response.text() + elif response.status == 400: + # Input contains a syntax error + error_message = await response.text() + raise black.InvalidInput(error_message) + elif response.status == 500: + # Other kind of error while formatting + error_message = await response.text() + raise RuntimeError(f"Error while formatting: {error_message}") + else: + # Unexpected response status code + raise RuntimeError( + f"Unexpected response status code: {response.status}" + ) diff --git a/src/blackd/middlewares.py b/src/blackd/middlewares.py new file mode 100644 index 0000000..4b2ccc9 --- /dev/null +++ b/src/blackd/middlewares.py @@ -0,0 +1,45 @@ +from collections.abc import Awaitable, Callable, Collection, Iterable + +from aiohttp import web +from aiohttp.typedefs import Middleware +from aiohttp.web_middlewares import middleware +from aiohttp.web_request import Request +from aiohttp.web_response import StreamResponse + +Handler = Callable[[Request], Awaitable[StreamResponse]] + + +def cors( + *, + allow_headers: Iterable[str], + allow_origins: Collection[str], + expose_headers: Iterable[str], +) -> Middleware: + @middleware + async def impl(request: Request, handler: Handler) -> StreamResponse: + origin = request.headers.get("Origin") + if not origin: + return await handler(request) + + if origin not in allow_origins: + return web.Response(status=403, text="CORS origin is not allowed") + + is_options = request.method == "OPTIONS" + is_preflight = is_options and "Access-Control-Request-Method" in request.headers + if is_preflight: + resp = StreamResponse() + else: + resp = await handler(request) + + resp.headers["Access-Control-Allow-Origin"] = origin + if expose_headers: + resp.headers["Access-Control-Expose-Headers"] = ", ".join(expose_headers) + if is_options: + resp.headers["Access-Control-Allow-Headers"] = ", ".join(allow_headers) + resp.headers["Access-Control-Allow-Methods"] = ", ".join( + ("OPTIONS", "POST") + ) + + return resp + + return impl diff --git a/src/blib2to3/Grammar.txt b/src/blib2to3/Grammar.txt new file mode 100644 index 0000000..2bd54bd --- /dev/null +++ b/src/blib2to3/Grammar.txt @@ -0,0 +1,267 @@ +# Grammar for 2to3. This grammar supports Python 2.x and 3.x. + +# NOTE WELL: You should also follow all the steps listed at +# https://devguide.python.org/grammar/ + +# Start symbols for the grammar: +# file_input is a module or sequence of commands read from an input file; +# single_input is a single interactive statement; +# eval_input is the input for the eval() and input() functions. +# NB: compound_stmt in single_input is followed by extra NEWLINE! +file_input: (NEWLINE | stmt)* ENDMARKER +single_input: NEWLINE | simple_stmt | compound_stmt NEWLINE +eval_input: testlist NEWLINE* ENDMARKER + +typevar: NAME [':' test] ['=' test] +paramspec: '**' NAME ['=' test] +typevartuple: '*' NAME ['=' (test|star_expr)] +typeparam: typevar | paramspec | typevartuple +typeparams: '[' typeparam (',' typeparam)* [','] ']' + +decorator: '@' namedexpr_test NEWLINE +decorators: decorator+ +decorated: decorators (classdef | funcdef | async_funcdef) +async_funcdef: ASYNC funcdef +funcdef: 'def' NAME [typeparams] parameters ['->' test] ':' suite +parameters: '(' [typedargslist] ')' + +# The following definition for typedarglist is equivalent to this set of rules: +# +# arguments = argument (',' argument)* +# argument = tfpdef ['=' test] +# kwargs = '**' tname [','] +# args = '*' [tname_star] +# kwonly_kwargs = (',' argument)* [',' [kwargs]] +# args_kwonly_kwargs = args kwonly_kwargs | kwargs +# poskeyword_args_kwonly_kwargs = arguments [',' [args_kwonly_kwargs]] +# typedargslist_no_posonly = poskeyword_args_kwonly_kwargs | args_kwonly_kwargs +# typedarglist = arguments ',' '/' [',' [typedargslist_no_posonly]])|(typedargslist_no_posonly)" +# +# It needs to be fully expanded to allow our LL(1) parser to work on it. + +typedargslist: tfpdef ['=' test] (',' tfpdef ['=' test])* ',' '/' [ + ',' [((tfpdef ['=' test] ',')* ('*' [tname_star] (',' tname ['=' test])* + [',' ['**' tname [',']]] | '**' tname [',']) + | tfpdef ['=' test] (',' tfpdef ['=' test])* [','])] + ] | ((tfpdef ['=' test] ',')* ('*' [tname_star] (',' tname ['=' test])* + [',' ['**' tname [',']]] | '**' tname [',']) + | tfpdef ['=' test] (',' tfpdef ['=' test])* [',']) + +tname: NAME [':' test] +tname_star: NAME [':' (test|star_expr)] +tfpdef: tname | '(' tfplist ')' +tfplist: tfpdef (',' tfpdef)* [','] + +# The following definition for varargslist is equivalent to this set of rules: +# +# arguments = argument (',' argument )* +# argument = vfpdef ['=' test] +# kwargs = '**' vname [','] +# args = '*' [vname] +# kwonly_kwargs = (',' argument )* [',' [kwargs]] +# args_kwonly_kwargs = args kwonly_kwargs | kwargs +# poskeyword_args_kwonly_kwargs = arguments [',' [args_kwonly_kwargs]] +# vararglist_no_posonly = poskeyword_args_kwonly_kwargs | args_kwonly_kwargs +# varargslist = arguments ',' '/' [','[(vararglist_no_posonly)]] | (vararglist_no_posonly) +# +# It needs to be fully expanded to allow our LL(1) parser to work on it. + +varargslist: vfpdef ['=' test ](',' vfpdef ['=' test])* ',' '/' [',' [ + ((vfpdef ['=' test] ',')* ('*' [vname] (',' vname ['=' test])* + [',' ['**' vname [',']]] | '**' vname [',']) + | vfpdef ['=' test] (',' vfpdef ['=' test])* [',']) + ]] | ((vfpdef ['=' test] ',')* + ('*' [vname] (',' vname ['=' test])* [',' ['**' vname [',']]]| '**' vname [',']) + | vfpdef ['=' test] (',' vfpdef ['=' test])* [',']) + +vname: NAME +vfpdef: vname | '(' vfplist ')' +vfplist: vfpdef (',' vfpdef)* [','] + +stmt: simple_stmt | compound_stmt +simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE +small_stmt: (type_stmt | expr_stmt | del_stmt | pass_stmt | flow_stmt | + import_stmt | global_stmt | assert_stmt) +expr_stmt: testlist_star_expr (annassign | augassign (yield_expr|testlist) | + ('=' (yield_expr|testlist_star_expr))*) +annassign: ':' test ['=' (yield_expr|testlist_star_expr)] +testlist_star_expr: (test|star_expr) (',' (test|star_expr))* [','] +augassign: ('+=' | '-=' | '*=' | '@=' | '/=' | '%=' | '&=' | '|=' | '^=' | + '<<=' | '>>=' | '**=' | '//=') +# For normal and annotated assignments, additional restrictions enforced by the interpreter +del_stmt: 'del' exprlist +pass_stmt: 'pass' +flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt +break_stmt: 'break' +continue_stmt: 'continue' +return_stmt: 'return' [testlist_star_expr] +yield_stmt: yield_expr +raise_stmt: 'raise' [test ['from' test | ',' test [',' test]]] +import_stmt: import_name | import_from | lazy_import +lazy_import: LAZY (import_name | import_from) +import_name: 'import' dotted_as_names +import_from: ('from' ('.'* dotted_name | '.'+) + 'import' ('*' | '(' import_as_names ')' | import_as_names)) +import_as_name: NAME ['as' NAME] +dotted_as_name: dotted_name ['as' NAME] +import_as_names: import_as_name (',' import_as_name)* [','] +dotted_as_names: dotted_as_name (',' dotted_as_name)* +dotted_name: NAME ('.' NAME)* +global_stmt: ('global' | 'nonlocal') NAME (',' NAME)* +assert_stmt: 'assert' test [',' test] +type_stmt: "type" NAME [typeparams] '=' test + +compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | with_stmt | funcdef | classdef | decorated | async_stmt | match_stmt +async_stmt: ASYNC (funcdef | with_stmt | for_stmt) +if_stmt: 'if' namedexpr_test ':' suite ('elif' namedexpr_test ':' suite)* ['else' ':' suite] +while_stmt: 'while' namedexpr_test ':' suite ['else' ':' suite] +for_stmt: 'for' exprlist 'in' testlist_star_expr ':' suite ['else' ':' suite] +try_stmt: ('try' ':' suite + ((except_clause ':' suite)+ + ['else' ':' suite] + ['finally' ':' suite] | + 'finally' ':' suite)) +with_stmt: 'with' asexpr_test (',' asexpr_test)* ':' suite + +# NB compile.c makes sure that the default except clause is last +except_clause: 'except' ['*'] [testlist ['as' test]] +suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT + +# Backward compatibility cruft to support: +# [ x for x in lambda: True, lambda: False if x() ] +# even while also allowing: +# lambda x: 5 if x else 2 +# (But not a mix of the two) +testlist_safe: old_test [(',' old_test)+ [',']] +old_test: or_test | old_lambdef +old_lambdef: 'lambda' [varargslist] ':' old_test + +namedexpr_test: asexpr_test [':=' asexpr_test] + +# This is actually not a real rule, though since the parser is very +# limited in terms of the strategy about match/case rules, we are inserting +# a virtual case ( as ) as a valid expression. Unless a better +# approach is thought, the only side effect of this seem to be just allowing +# more stuff to be parser (which would fail on the ast). +asexpr_test: test ['as' test] + +test: or_test ['if' or_test 'else' test] | lambdef +or_test: and_test ('or' and_test)* +and_test: not_test ('and' not_test)* +not_test: 'not' not_test | comparison +comparison: expr (comp_op expr)* +comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'|'is' 'not' +star_expr: '*' expr +expr: xor_expr ('|' xor_expr)* +xor_expr: and_expr ('^' and_expr)* +and_expr: shift_expr ('&' shift_expr)* +shift_expr: arith_expr (('<<'|'>>') arith_expr)* +arith_expr: term (('+'|'-') term)* +term: factor (('*'|'@'|'/'|'%'|'//') factor)* +factor: ('+'|'-'|'~') factor | power +power: [AWAIT] atom trailer* ['**' factor] +atom: ('(' [yield_expr|testlist_gexp] ')' | + '[' [listmaker] ']' | + '{' [dictsetmaker] '}' | + '`' testlist1 '`' | + NAME | NUMBER | (STRING | fstring | tstring)+ | '.' '.' '.') +listmaker: (namedexpr_test|star_expr) ( old_comp_for | (',' (namedexpr_test|star_expr))* [','] ) +testlist_gexp: (namedexpr_test|star_expr) ( old_comp_for | (',' (namedexpr_test|star_expr))* [','] ) +lambdef: 'lambda' [varargslist] ':' test +trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME +subscriptlist: (subscript|star_expr) (',' (subscript|star_expr))* [','] +subscript: test [':=' test] | [test] ':' [test] [sliceop] +sliceop: ':' [test] +exprlist: (expr|star_expr) (',' (expr|star_expr))* [','] +testlist: test (',' test)* [','] +dictsetmaker: ( ((test ':' asexpr_test | '**' expr) + (comp_for | (',' (test ':' asexpr_test | '**' expr))* [','])) | + ((test [':=' test] | star_expr) + (comp_for | (',' (test [':=' test] | star_expr))* [','])) ) + +classdef: 'class' NAME [typeparams] ['(' [arglist] ')'] ':' suite + +arglist: argument (',' argument)* [','] + +# "test '=' test" is really "keyword '=' test", but we have no such token. +# These need to be in a single rule to avoid grammar that is ambiguous +# to our LL(1) parser. Even though 'test' includes '*expr' in star_expr, +# we explicitly match '*' here, too, to give it proper precedence. +# Illegal combinations and orderings are blocked in ast.c: +# multiple (test comp_for) arguments are blocked; keyword unpackings +# that precede iterable unpackings are blocked; etc. +argument: ( test [comp_for] | + test ':=' test [comp_for] | + test 'as' test | + test '=' asexpr_test | + '**' test | + '*' test ) + +comp_iter: comp_for | comp_if +comp_for: [ASYNC] 'for' exprlist 'in' or_test [comp_iter] +comp_if: 'if' old_test [comp_iter] + +# As noted above, testlist_safe extends the syntax allowed in list +# comprehensions and generators. We can't use it indiscriminately in all +# derivations using a comp_for-like pattern because the testlist_safe derivation +# contains comma which clashes with trailing comma in arglist. +# +# This was an issue because the parser would not follow the correct derivation +# when parsing syntactically valid Python code. Since testlist_safe was created +# specifically to handle list comprehensions and generator expressions enclosed +# with parentheses, it's safe to only use it in those. That avoids the issue; we +# can parse code like set(x for x in [],). +# +# The syntax supported by this set of rules is not a valid Python 3 syntax, +# hence the prefix "old". +# +# See https://bugs.python.org/issue27494 +old_comp_iter: old_comp_for | old_comp_if +old_comp_for: [ASYNC] 'for' exprlist 'in' testlist_safe [old_comp_iter] +old_comp_if: 'if' old_test [old_comp_iter] + +testlist1: test (',' test)* + +# not used in grammar, but may appear in "node" passed from Parser to Compiler +encoding_decl: NAME + +yield_expr: 'yield' [yield_arg] +yield_arg: 'from' test | testlist_star_expr + + +# 3.10 match statement definition + +# PS: normally the grammar is much much more restricted, but +# at this moment for not trying to bother much with encoding the +# exact same DSL in a LL(1) parser, we will just accept an expression +# and let the ast.parse() step of the safe mode to reject invalid +# grammar. + +# The reason why it is more restricted is that, patterns are some +# sort of a DSL (more advanced than our LHS on assignments, but +# still in a very limited python subset). They are not really +# expressions, but who cares. If we can parse them, that is enough +# to reformat them. + +match_stmt: "match" subject_expr ':' NEWLINE INDENT case_block+ DEDENT + +# This is more permissive than the actual version. For example it +# accepts `match *something:`, even though single-item starred expressions +# are forbidden. +subject_expr: (namedexpr_test|star_expr) (',' (namedexpr_test|star_expr))* [','] + +# cases +case_block: "case" patterns [guard] ':' suite +guard: 'if' namedexpr_test +patterns: pattern (',' pattern)* [','] +pattern: (expr|star_expr) ['as' expr] + +fstring: FSTRING_START fstring_middle* FSTRING_END +fstring_middle: fstring_replacement_field | FSTRING_MIDDLE +fstring_replacement_field: '{' (yield_expr | testlist_star_expr) ['='] [ "!" NAME ] [ ':' fstring_format_spec* ] '}' +fstring_format_spec: FSTRING_MIDDLE | fstring_replacement_field + +tstring: TSTRING_START tstring_middle* TSTRING_END +tstring_middle: tstring_replacement_field | TSTRING_MIDDLE +tstring_replacement_field: '{' (yield_expr | testlist_star_expr) ['='] [ "!" NAME ] [ ':' tstring_format_spec* ] '}' +tstring_format_spec: TSTRING_MIDDLE | tstring_replacement_field diff --git a/src/blib2to3/LICENSE b/src/blib2to3/LICENSE new file mode 100644 index 0000000..ef8df06 --- /dev/null +++ b/src/blib2to3/LICENSE @@ -0,0 +1,254 @@ +A. HISTORY OF THE SOFTWARE +========================== + +Python was created in the early 1990s by Guido van Rossum at Stichting +Mathematisch Centrum (CWI, see https://www.cwi.nl) in the Netherlands +as a successor of a language called ABC. Guido remains Python's +principal author, although it includes many contributions from others. + +In 1995, Guido continued his work on Python at the Corporation for +National Research Initiatives (CNRI, see https://www.cnri.reston.va.us) +in Reston, Virginia where he released several versions of the +software. + +In May 2000, Guido and the Python core development team moved to +BeOpen.com to form the BeOpen PythonLabs team. In October of the same +year, the PythonLabs team moved to Digital Creations, which became +Zope Corporation. In 2001, the Python Software Foundation (PSF, see +https://www.python.org/psf/) was formed, a non-profit organization +created specifically to own Python-related Intellectual Property. +Zope Corporation was a sponsoring member of the PSF. + +All Python releases are Open Source (see https://opensource.org for +the Open Source Definition). Historically, most, but not all, Python +releases have also been GPL-compatible; the table below summarizes +the various releases. + + Release Derived Year Owner GPL- + from compatible? (1) + + 0.9.0 thru 1.2 1991-1995 CWI yes + 1.3 thru 1.5.2 1.2 1995-1999 CNRI yes + 1.6 1.5.2 2000 CNRI no + 2.0 1.6 2000 BeOpen.com no + 1.6.1 1.6 2001 CNRI yes (2) + 2.1 2.0+1.6.1 2001 PSF no + 2.0.1 2.0+1.6.1 2001 PSF yes + 2.1.1 2.1+2.0.1 2001 PSF yes + 2.1.2 2.1.1 2002 PSF yes + 2.1.3 2.1.2 2002 PSF yes + 2.2 and above 2.1.1 2001-now PSF yes + +Footnotes: + +(1) GPL-compatible doesn't mean that we're distributing Python under + the GPL. All Python licenses, unlike the GPL, let you distribute + a modified version without making your changes open source. The + GPL-compatible licenses make it possible to combine Python with + other software that is released under the GPL; the others don't. + +(2) According to Richard Stallman, 1.6.1 is not GPL-compatible, + because its license has a choice of law clause. According to + CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1 + is "not incompatible" with the GPL. + +Thanks to the many outside volunteers who have worked under Guido's +direction to make these releases possible. + + +B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON +=============================================================== + +PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 +-------------------------------------------- + +1. This LICENSE AGREEMENT is between the Python Software Foundation +("PSF"), and the Individual or Organization ("Licensee") accessing and +otherwise using this software ("Python") in source or binary form and +its associated documentation. + +2. Subject to the terms and conditions of this License Agreement, PSF hereby +grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce, +analyze, test, perform and/or display publicly, prepare derivative works, +distribute, and otherwise use Python alone or in any derivative version, +provided, however, that PSF's License Agreement and PSF's notice of copyright, +i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, +2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 Python Software Foundation; All +Rights Reserved" are retained in Python alone or in any derivative version +prepared by Licensee. + +3. In the event Licensee prepares a derivative work that is based on +or incorporates Python or any part thereof, and wants to make +the derivative work available to others as provided herein, then +Licensee hereby agrees to include in any such work a brief summary of +the changes made to Python. + +4. PSF is making Python available to Licensee on an "AS IS" +basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR +IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND +DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS +FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT +INFRINGE ANY THIRD PARTY RIGHTS. + +5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON +FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS +A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, +OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. + +6. This License Agreement will automatically terminate upon a material +breach of its terms and conditions. + +7. Nothing in this License Agreement shall be deemed to create any +relationship of agency, partnership, or joint venture between PSF and +Licensee. This License Agreement does not grant permission to use PSF +trademarks or trade name in a trademark sense to endorse or promote +products or services of Licensee, or any third party. + +8. By copying, installing or otherwise using Python, Licensee +agrees to be bound by the terms and conditions of this License +Agreement. + + +BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0 +------------------------------------------- + +BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1 + +1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an +office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the +Individual or Organization ("Licensee") accessing and otherwise using +this software in source or binary form and its associated +documentation ("the Software"). + +2. Subject to the terms and conditions of this BeOpen Python License +Agreement, BeOpen hereby grants Licensee a non-exclusive, +royalty-free, world-wide license to reproduce, analyze, test, perform +and/or display publicly, prepare derivative works, distribute, and +otherwise use the Software alone or in any derivative version, +provided, however, that the BeOpen Python License is retained in the +Software, alone or in any derivative version prepared by Licensee. + +3. BeOpen is making the Software available to Licensee on an "AS IS" +basis. BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR +IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND +DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS +FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT +INFRINGE ANY THIRD PARTY RIGHTS. + +4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE +SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS +AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY +DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. + +5. This License Agreement will automatically terminate upon a material +breach of its terms and conditions. + +6. This License Agreement shall be governed by and interpreted in all +respects by the law of the State of California, excluding conflict of +law provisions. Nothing in this License Agreement shall be deemed to +create any relationship of agency, partnership, or joint venture +between BeOpen and Licensee. This License Agreement does not grant +permission to use BeOpen trademarks or trade names in a trademark +sense to endorse or promote products or services of Licensee, or any +third party. As an exception, the "BeOpen Python" logos available at +http://www.pythonlabs.com/logos.html may be used according to the +permissions granted on that web page. + +7. By copying, installing or otherwise using the software, Licensee +agrees to be bound by the terms and conditions of this License +Agreement. + + +CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1 +--------------------------------------- + +1. This LICENSE AGREEMENT is between the Corporation for National +Research Initiatives, having an office at 1895 Preston White Drive, +Reston, VA 20191 ("CNRI"), and the Individual or Organization +("Licensee") accessing and otherwise using Python 1.6.1 software in +source or binary form and its associated documentation. + +2. Subject to the terms and conditions of this License Agreement, CNRI +hereby grants Licensee a nonexclusive, royalty-free, world-wide +license to reproduce, analyze, test, perform and/or display publicly, +prepare derivative works, distribute, and otherwise use Python 1.6.1 +alone or in any derivative version, provided, however, that CNRI's +License Agreement and CNRI's notice of copyright, i.e., "Copyright (c) +1995-2001 Corporation for National Research Initiatives; All Rights +Reserved" are retained in Python 1.6.1 alone or in any derivative +version prepared by Licensee. Alternately, in lieu of CNRI's License +Agreement, Licensee may substitute the following text (omitting the +quotes): "Python 1.6.1 is made available subject to the terms and +conditions in CNRI's License Agreement. This Agreement together with +Python 1.6.1 may be located on the Internet using the following +unique, persistent identifier (known as a handle): 1895.22/1013. This +Agreement may also be obtained from a proxy server on the Internet +using the following URL: http://hdl.handle.net/1895.22/1013". + +3. In the event Licensee prepares a derivative work that is based on +or incorporates Python 1.6.1 or any part thereof, and wants to make +the derivative work available to others as provided herein, then +Licensee hereby agrees to include in any such work a brief summary of +the changes made to Python 1.6.1. + +4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS" +basis. CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR +IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND +DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS +FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT +INFRINGE ANY THIRD PARTY RIGHTS. + +5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON +1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS +A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1, +OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. + +6. This License Agreement will automatically terminate upon a material +breach of its terms and conditions. + +7. This License Agreement shall be governed by the federal +intellectual property law of the United States, including without +limitation the federal copyright law, and, to the extent such +U.S. federal law does not apply, by the law of the Commonwealth of +Virginia, excluding Virginia's conflict of law provisions. +Notwithstanding the foregoing, with regard to derivative works based +on Python 1.6.1 that incorporate non-separable material that was +previously distributed under the GNU General Public License (GPL), the +law of the Commonwealth of Virginia shall govern this License +Agreement only as to issues arising under or with respect to +Paragraphs 4, 5, and 7 of this License Agreement. Nothing in this +License Agreement shall be deemed to create any relationship of +agency, partnership, or joint venture between CNRI and Licensee. This +License Agreement does not grant permission to use CNRI trademarks or +trade name in a trademark sense to endorse or promote products or +services of Licensee, or any third party. + +8. By clicking on the "ACCEPT" button where indicated, or by copying, +installing or otherwise using Python 1.6.1, Licensee agrees to be +bound by the terms and conditions of this License Agreement. + + ACCEPT + + +CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2 +-------------------------------------------------- + +Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam, +The Netherlands. All rights reserved. + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of Stichting Mathematisch +Centrum or CWI not be used in advertising or publicity pertaining to +distribution of the software without specific, written prior +permission. + +STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO +THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE +FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT +OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. diff --git a/src/blib2to3/PatternGrammar.txt b/src/blib2to3/PatternGrammar.txt new file mode 100644 index 0000000..e4b7981 --- /dev/null +++ b/src/blib2to3/PatternGrammar.txt @@ -0,0 +1,28 @@ +# Copyright 2006 Google, Inc. All Rights Reserved. +# Licensed to PSF under a Contributor Agreement. + +# A grammar to describe tree matching patterns. +# Not shown here: +# - 'TOKEN' stands for any token (leaf node) +# - 'any' stands for any node (leaf or interior) +# With 'any' we can still specify the sub-structure. + +# The start symbol is 'Matcher'. + +Matcher: Alternatives ENDMARKER + +Alternatives: Alternative ('|' Alternative)* + +Alternative: (Unit | NegatedUnit)+ + +Unit: [NAME '='] ( STRING [Repeater] + | NAME [Details] [Repeater] + | '(' Alternatives ')' [Repeater] + | '[' Alternatives ']' + ) + +NegatedUnit: 'not' (STRING | NAME [Details] | '(' Alternatives ')') + +Repeater: '*' | '+' | '{' NUMBER [',' NUMBER] '}' + +Details: '<' Alternatives '>' diff --git a/src/blib2to3/README b/src/blib2to3/README new file mode 100644 index 0000000..38b0415 --- /dev/null +++ b/src/blib2to3/README @@ -0,0 +1,24 @@ +A subset of lib2to3 taken from Python 3.7.0b2. Commit hash: +9c17e3a1987004b8bcfbe423953aad84493a7984 + +Reasons for forking: + +- consistent handling of f-strings for users of Python < 3.6.2 +- backport of BPO-33064 that fixes parsing files with trailing commas after \*args and + \*\*kwargs +- backport of GH-6143 that restores the ability to reformat legacy usage of `async` +- support all types of string literals +- better ability to debug (better reprs) +- INDENT and DEDENT don't hold whitespace and comment prefixes +- ability to Cythonize + +Change Log: + +- Changes default logger used by Driver +- Backported the following upstream parser changes: + - "bpo-42381: Allow walrus in set literals and set comprehensions (GH-23332)" + https://github.com/python/cpython/commit/cae60187cf7a7b26281d012e1952fafe4e2e97e9 + - "bpo-42316: Allow unparenthesized walrus operator in indexes (GH-23317)" + https://github.com/python/cpython/commit/b0aba1fcdc3da952698d99aec2334faa79a8b68c +- Tweaks to help mypyc compile faster code (including inlining type information, + "Final-ing", etc.) diff --git a/src/blib2to3/__init__.py b/src/blib2to3/__init__.py new file mode 100644 index 0000000..1bb8bf6 --- /dev/null +++ b/src/blib2to3/__init__.py @@ -0,0 +1 @@ +# empty diff --git a/src/blib2to3/pgen2/__init__.py b/src/blib2to3/pgen2/__init__.py new file mode 100644 index 0000000..af39048 --- /dev/null +++ b/src/blib2to3/pgen2/__init__.py @@ -0,0 +1,4 @@ +# Copyright 2004-2005 Elemental Security, Inc. All Rights Reserved. +# Licensed to PSF under a Contributor Agreement. + +"""The pgen2 package.""" diff --git a/src/blib2to3/pgen2/conv.py b/src/blib2to3/pgen2/conv.py new file mode 100644 index 0000000..b936465 --- /dev/null +++ b/src/blib2to3/pgen2/conv.py @@ -0,0 +1,256 @@ +# Copyright 2004-2005 Elemental Security, Inc. All Rights Reserved. +# Licensed to PSF under a Contributor Agreement. + +# mypy: ignore-errors + +"""Convert graminit.[ch] spit out by pgen to Python code. + +Pgen is the Python parser generator. It is useful to quickly create a +parser from a grammar file in Python's grammar notation. But I don't +want my parsers to be written in C (yet), so I'm translating the +parsing tables to Python data structures and writing a Python parse +engine. + +Note that the token numbers are constants determined by the standard +Python tokenizer. The standard token module defines these numbers and +their names (the names are not used much). The token numbers are +hardcoded into the Python tokenizer and into pgen. A Python +implementation of the Python tokenizer is also available, in the +standard tokenize module. + +On the other hand, symbol numbers (representing the grammar's +non-terminals) are assigned by pgen based on the actual grammar +input. + +Note: this module is pretty much obsolete; the pgen module generates +equivalent grammar tables directly from the Grammar.txt input file +without having to invoke the Python pgen C program. + +""" + +# Python imports +import re + +# Local imports +from blib2to3.pgen2 import grammar, token + + +class Converter(grammar.Grammar): + """Grammar subclass that reads classic pgen output files. + + The run() method reads the tables as produced by the pgen parser + generator, typically contained in two C files, graminit.h and + graminit.c. The other methods are for internal use only. + + See the base class for more documentation. + + """ + + def run(self, graminit_h, graminit_c): + """Load the grammar tables from the text files written by pgen.""" + self.parse_graminit_h(graminit_h) + self.parse_graminit_c(graminit_c) + self.finish_off() + + def parse_graminit_h(self, filename): + """Parse the .h file written by pgen. (Internal) + + This file is a sequence of #define statements defining the + nonterminals of the grammar as numbers. We build two tables + mapping the numbers to names and back. + + """ + try: + f = open(filename) + except OSError as err: + print(f"Can't open {filename}: {err}") + return False + self.symbol2number = {} + self.number2symbol = {} + lineno = 0 + for line in f: + lineno += 1 + mo = re.match(r"^#define\s+(\w+)\s+(\d+)$", line) + if not mo and line.strip(): + print(f"{filename}({lineno}): can't parse {line.strip()}") + else: + symbol, number = mo.groups() + number = int(number) + assert symbol not in self.symbol2number + assert number not in self.number2symbol + self.symbol2number[symbol] = number + self.number2symbol[number] = symbol + return True + + def parse_graminit_c(self, filename): + """Parse the .c file written by pgen. (Internal) + + The file looks as follows. The first two lines are always this: + + #include "pgenheaders.h" + #include "grammar.h" + + After that come four blocks: + + 1) one or more state definitions + 2) a table defining dfas + 3) a table defining labels + 4) a struct defining the grammar + + A state definition has the following form: + - one or more arc arrays, each of the form: + static arc arcs__[] = { + {, }, + ... + }; + - followed by a state array, of the form: + static state states_[] = { + {, arcs__}, + ... + }; + + """ + try: + f = open(filename) + except OSError as err: + print(f"Can't open {filename}: {err}") + return False + # The code below essentially uses f's iterator-ness! + lineno = 0 + + # Expect the two #include lines + lineno, line = lineno + 1, next(f) + assert line == '#include "pgenheaders.h"\n', (lineno, line) + lineno, line = lineno + 1, next(f) + assert line == '#include "grammar.h"\n', (lineno, line) + + # Parse the state definitions + lineno, line = lineno + 1, next(f) + allarcs = {} + states = [] + while line.startswith("static arc "): + while line.startswith("static arc "): + mo = re.match(r"static arc arcs_(\d+)_(\d+)\[(\d+)\] = {$", line) + assert mo, (lineno, line) + n, m, k = list(map(int, mo.groups())) + arcs = [] + for _ in range(k): + lineno, line = lineno + 1, next(f) + mo = re.match(r"\s+{(\d+), (\d+)},$", line) + assert mo, (lineno, line) + i, j = list(map(int, mo.groups())) + arcs.append((i, j)) + lineno, line = lineno + 1, next(f) + assert line == "};\n", (lineno, line) + allarcs[(n, m)] = arcs + lineno, line = lineno + 1, next(f) + mo = re.match(r"static state states_(\d+)\[(\d+)\] = {$", line) + assert mo, (lineno, line) + s, t = list(map(int, mo.groups())) + assert s == len(states), (lineno, line) + state = [] + for _ in range(t): + lineno, line = lineno + 1, next(f) + mo = re.match(r"\s+{(\d+), arcs_(\d+)_(\d+)},$", line) + assert mo, (lineno, line) + k, n, m = list(map(int, mo.groups())) + arcs = allarcs[n, m] + assert k == len(arcs), (lineno, line) + state.append(arcs) + states.append(state) + lineno, line = lineno + 1, next(f) + assert line == "};\n", (lineno, line) + lineno, line = lineno + 1, next(f) + self.states = states + + # Parse the dfas + dfas = {} + mo = re.match(r"static dfa dfas\[(\d+)\] = {$", line) + assert mo, (lineno, line) + ndfas = int(mo.group(1)) + for i in range(ndfas): + lineno, line = lineno + 1, next(f) + mo = re.match(r'\s+{(\d+), "(\w+)", (\d+), (\d+), states_(\d+),$', line) + assert mo, (lineno, line) + symbol = mo.group(2) + number, x, y, z = list(map(int, mo.group(1, 3, 4, 5))) + assert self.symbol2number[symbol] == number, (lineno, line) + assert self.number2symbol[number] == symbol, (lineno, line) + assert x == 0, (lineno, line) + state = states[z] + assert y == len(state), (lineno, line) + lineno, line = lineno + 1, next(f) + mo = re.match(r'\s+("(?:\\\d\d\d)*")},$', line) + assert mo, (lineno, line) + first = {} + rawbitset = eval(mo.group(1)) + for i, c in enumerate(rawbitset): + byte = ord(c) + for j in range(8): + if byte & (1 << j): + first[i * 8 + j] = 1 + dfas[number] = (state, first) + lineno, line = lineno + 1, next(f) + assert line == "};\n", (lineno, line) + self.dfas = dfas + + # Parse the labels + labels = [] + lineno, line = lineno + 1, next(f) + mo = re.match(r"static label labels\[(\d+)\] = {$", line) + assert mo, (lineno, line) + nlabels = int(mo.group(1)) + for i in range(nlabels): + lineno, line = lineno + 1, next(f) + mo = re.match(r'\s+{(\d+), (0|"\w+")},$', line) + assert mo, (lineno, line) + x, y = mo.groups() + x = int(x) + if y == "0": + y = None + else: + y = eval(y) + labels.append((x, y)) + lineno, line = lineno + 1, next(f) + assert line == "};\n", (lineno, line) + self.labels = labels + + # Parse the grammar struct + lineno, line = lineno + 1, next(f) + assert line == "grammar _PyParser_Grammar = {\n", (lineno, line) + lineno, line = lineno + 1, next(f) + mo = re.match(r"\s+(\d+),$", line) + assert mo, (lineno, line) + ndfas = int(mo.group(1)) + assert ndfas == len(self.dfas) + lineno, line = lineno + 1, next(f) + assert line == "\tdfas,\n", (lineno, line) + lineno, line = lineno + 1, next(f) + mo = re.match(r"\s+{(\d+), labels},$", line) + assert mo, (lineno, line) + nlabels = int(mo.group(1)) + assert nlabels == len(self.labels), (lineno, line) + lineno, line = lineno + 1, next(f) + mo = re.match(r"\s+(\d+)$", line) + assert mo, (lineno, line) + start = int(mo.group(1)) + assert start in self.number2symbol, (lineno, line) + self.start = start + lineno, line = lineno + 1, next(f) + assert line == "};\n", (lineno, line) + try: + lineno, line = lineno + 1, next(f) + except StopIteration: + pass + else: + assert 0, (lineno, line) + + def finish_off(self): + """Create additional useful structures. (Internal).""" + self.keywords = {} # map from keyword strings to arc labels + self.tokens = {} # map from numeric token values to arc labels + for ilabel, (type, value) in enumerate(self.labels): + if type == token.NAME and value is not None: + self.keywords[value] = ilabel + elif value is None: + self.tokens[type] = ilabel diff --git a/src/blib2to3/pgen2/driver.py b/src/blib2to3/pgen2/driver.py new file mode 100644 index 0000000..9893c20 --- /dev/null +++ b/src/blib2to3/pgen2/driver.py @@ -0,0 +1,322 @@ +# Copyright 2004-2005 Elemental Security, Inc. All Rights Reserved. +# Licensed to PSF under a Contributor Agreement. + +# Modifications: +# Copyright 2006 Google, Inc. All Rights Reserved. +# Licensed to PSF under a Contributor Agreement. + +"""Parser driver. + +This provides a high-level interface to parse a file into a syntax tree. + +""" + +__author__ = "Guido van Rossum " + +__all__ = ["Driver", "load_grammar"] + +# Python imports +import io +import logging +import os +import pkgutil +import sys +from collections.abc import Iterable, Iterator +from contextlib import contextmanager +from dataclasses import dataclass, field +from logging import Logger +from typing import Any, Union, cast + +from blib2to3.pgen2.grammar import Grammar +from blib2to3.pgen2.tokenize import TokenInfo +from blib2to3.pytree import NL + +# Pgen imports +from . import grammar, parse, pgen, token, tokenize + +Path = Union[str, "os.PathLike[str]"] + + +@dataclass +class ReleaseRange: + start: int + end: int | None = None + tokens: list[Any] = field(default_factory=list) + + def lock(self) -> None: + total_eaten = len(self.tokens) + self.end = self.start + total_eaten + + +class TokenProxy: + def __init__(self, generator: Any) -> None: + self._tokens = generator + self._counter = 0 + self._release_ranges: list[ReleaseRange] = [] + + @contextmanager + def release(self) -> Iterator["TokenProxy"]: + release_range = ReleaseRange(self._counter) + self._release_ranges.append(release_range) + try: + yield self + finally: + # Lock the last release range to the final position that + # has been eaten. + release_range.lock() + + def eat(self, point: int) -> Any: + eaten_tokens = self._release_ranges[-1].tokens + if point < len(eaten_tokens): + return eaten_tokens[point] + else: + while point >= len(eaten_tokens): + token = next(self._tokens) + eaten_tokens.append(token) + return token + + def __iter__(self) -> "TokenProxy": + return self + + def __next__(self) -> Any: + # If the current position is already compromised (looked up) + # return the eaten token, if not just go further on the given + # token producer. + # Ranges are appended in counter order and the counter only moves + # forward, so any range we've already advanced past can never match + # again. Drop that exhausted prefix; otherwise the scan below grows + # with the number of soft-keyword lookaheads and parsing a file full + # of them (e.g. many `match`/`case` blocks) becomes quadratic. + ranges = self._release_ranges + while ranges and ranges[0].end is not None and ranges[0].end <= self._counter: + ranges.pop(0) + + for release_range in ranges: + assert release_range.end is not None + + start, end = release_range.start, release_range.end + if start <= self._counter < end: + token = release_range.tokens[self._counter - start] + break + else: + token = next(self._tokens) + self._counter += 1 + return token + + def can_advance(self, to: int) -> bool: + # Try to eat, fail if it can't. The eat operation is cached + # so there won't be any additional cost of eating here + try: + self.eat(to) + except StopIteration: + return False + else: + return True + + +class Driver: + def __init__(self, grammar: Grammar, logger: Logger | None = None) -> None: + self.grammar = grammar + if logger is None: + logger = logging.getLogger(__name__) + self.logger = logger + + def parse_tokens(self, tokens: Iterable[TokenInfo], debug: bool = False) -> NL: + """Parse a series of tokens and return the syntax tree.""" + # XXX Move the prefix computation into a wrapper around tokenize. + proxy = TokenProxy(tokens) + + p = parse.Parser(self.grammar) + p.setup(proxy=proxy) + + lineno = 1 + column = 0 + indent_columns: list[int] = [] + type = value = start = end = line_text = None + prefix = "" + + for quintuple in proxy: + type, value, start, end, line_text = quintuple + if start != (lineno, column): + assert (lineno, column) <= start, ((lineno, column), start) + s_lineno, s_column = start + if lineno < s_lineno: + prefix += "\n" * (s_lineno - lineno) + lineno = s_lineno + column = 0 + if column < s_column: + prefix += line_text[column:s_column] + column = s_column + if type in (tokenize.COMMENT, tokenize.NL): + prefix += value + lineno, column = end + if value.endswith("\n"): + lineno += 1 + column = 0 + continue + if type == token.OP: + type = grammar.opmap[value] + if debug: + assert type is not None + self.logger.debug( + "%s %r (prefix=%r)", token.tok_name[type], value, prefix + ) + if type == token.INDENT: + indent_columns.append(len(value)) + _prefix = prefix + value + prefix = "" + value = "" + elif type == token.DEDENT: + _indent_col = indent_columns.pop() + prefix, _prefix = self._partially_consume_prefix(prefix, _indent_col) + if p.addtoken(cast(int, type), value, (prefix, start)): + if debug: + self.logger.debug("Stop.") + break + prefix = "" + if type in {token.INDENT, token.DEDENT}: + prefix = _prefix + lineno, column = end + # FSTRING_MIDDLE and TSTRING_MIDDLE are the only token that can end with a + # newline, and `end` will point to the next line. For that case, don't + # increment lineno. + if value.endswith("\n") and type not in ( + token.FSTRING_MIDDLE, + token.TSTRING_MIDDLE, + ): + lineno += 1 + column = 0 + else: + # We never broke out -- EOF is too soon (how can this happen???) + assert start is not None + raise parse.ParseError("incomplete input", type, value, (prefix, start)) + assert p.rootnode is not None + return p.rootnode + + def parse_file( + self, filename: Path, encoding: str | None = None, debug: bool = False + ) -> NL: + """Parse a file and return the syntax tree.""" + with open(filename, encoding=encoding) as stream: + text = stream.read() + return self.parse_string(text, debug) + + def parse_string(self, text: str, debug: bool = False) -> NL: + """Parse a string and return the syntax tree.""" + tokens = tokenize.tokenize(text, grammar=self.grammar) + return self.parse_tokens(tokens, debug) + + def _partially_consume_prefix(self, prefix: str, column: int) -> tuple[str, str]: + lines: list[str] = [] + current_line = "" + current_column = 0 + wait_for_nl = False + for char in prefix: + current_line += char + if wait_for_nl: + if char == "\n": + if current_line.strip() and current_column < column: + res = "".join(lines) + return res, prefix[len(res) :] + + lines.append(current_line) + current_line = "" + current_column = 0 + wait_for_nl = False + elif char in " \t": + current_column += 1 + elif char == "\n": + # unexpected empty line + current_column = 0 + elif char == "\f": + current_column = 0 + else: + # indent is finished + wait_for_nl = True + return "".join(lines), current_line + + +def _generate_pickle_name(gt: Path, cache_dir: Path | None = None) -> str: + head, tail = os.path.splitext(gt) + if tail == ".txt": + tail = "" + name = head + tail + ".".join(map(str, sys.version_info)) + ".pickle" + if cache_dir: + return os.path.join(cache_dir, os.path.basename(name)) + else: + return name + + +def load_grammar( + gt: str = "Grammar.txt", + gp: str | None = None, + save: bool = True, + force: bool = False, + logger: Logger | None = None, +) -> Grammar: + """Load the grammar (maybe from a pickle).""" + if logger is None: + logger = logging.getLogger(__name__) + gp = _generate_pickle_name(gt) if gp is None else gp + if force or not _newer(gp, gt): + g: grammar.Grammar = pgen.generate_grammar(gt) + if save: + try: + g.dump(gp) + except OSError: + # Ignore error, caching is not vital. + pass + else: + g = grammar.Grammar() + g.load(gp) + return g + + +def _newer(a: str, b: str) -> bool: + """Inquire whether file a was written since file b.""" + if not os.path.exists(a): + return False + if not os.path.exists(b): + return True + return os.path.getmtime(a) >= os.path.getmtime(b) + + +def load_packaged_grammar( + package: str, grammar_source: str, cache_dir: Path | None = None +) -> grammar.Grammar: + """Normally, loads a pickled grammar by doing + pkgutil.get_data(package, pickled_grammar) + where *pickled_grammar* is computed from *grammar_source* by adding the + Python version and using a ``.pickle`` extension. + + However, if *grammar_source* is an extant file, load_grammar(grammar_source) + is called instead. This facilitates using a packaged grammar file when needed + but preserves load_grammar's automatic regeneration behavior when possible. + + """ + if os.path.isfile(grammar_source): + gp = _generate_pickle_name(grammar_source, cache_dir) if cache_dir else None + return load_grammar(grammar_source, gp=gp) + pickled_name = _generate_pickle_name(os.path.basename(grammar_source), cache_dir) + data = pkgutil.get_data(package, pickled_name) + assert data is not None + g = grammar.Grammar() + g.loads(data) + return g + + +def main(*args: str) -> bool: + """Main program, when run as a script: produce grammar pickle files. + + Calls load_grammar for each argument, a path to a grammar text file. + """ + if not args: + args = tuple(sys.argv[1:]) + logging.basicConfig(level=logging.INFO, stream=sys.stdout, format="%(message)s") + for gt in args: + load_grammar(gt, save=True, force=True) + return True + + +if __name__ == "__main__": + sys.exit(int(not main())) diff --git a/src/blib2to3/pgen2/grammar.py b/src/blib2to3/pgen2/grammar.py new file mode 100644 index 0000000..9cf2403 --- /dev/null +++ b/src/blib2to3/pgen2/grammar.py @@ -0,0 +1,228 @@ +# Copyright 2004-2005 Elemental Security, Inc. All Rights Reserved. +# Licensed to PSF under a Contributor Agreement. + +"""This module defines the data structures used to represent a grammar. + +These are a bit arcane because they are derived from the data +structures used by Python's 'pgen' parser generator. + +There's also a table here mapping operators to their names in the +token module; the Python tokenize module reports all operators as the +fallback token code OP, but the parser needs the actual token code. + +""" + +# Python imports +import os +import pickle +import tempfile +from typing import Any, Optional, TypeVar, Union + +# Local imports +from . import token + +_P = TypeVar("_P", bound="Grammar") +Label = tuple[int, Optional[str]] +DFA = list[list[tuple[int, int]]] +DFAS = tuple[DFA, dict[int, int]] +Path = Union[str, "os.PathLike[str]"] + + +class Grammar: + """Pgen parsing tables conversion class. + + Once initialized, this class supplies the grammar tables for the + parsing engine implemented by parse.py. The parsing engine + accesses the instance variables directly. The class here does not + provide initialization of the tables; several subclasses exist to + do this (see the conv and pgen modules). + + The load() method reads the tables from a pickle file, which is + much faster than the other ways offered by subclasses. The pickle + file is written by calling dump() (after loading the grammar + tables using a subclass). The report() method prints a readable + representation of the tables to stdout, for debugging. + + The instance variables are as follows: + + symbol2number -- a dict mapping symbol names to numbers. Symbol + numbers are always 256 or higher, to distinguish + them from token numbers, which are between 0 and + 255 (inclusive). + + number2symbol -- a dict mapping numbers to symbol names; + these two are each other's inverse. + + states -- a list of DFAs, where each DFA is a list of + states, each state is a list of arcs, and each + arc is a (i, j) pair where i is a label and j is + a state number. The DFA number is the index into + this list. (This name is slightly confusing.) + Final states are represented by a special arc of + the form (0, j) where j is its own state number. + + dfas -- a dict mapping symbol numbers to (DFA, first) + pairs, where DFA is an item from the states list + above, and first is a set of tokens that can + begin this grammar rule (represented by a dict + whose values are always 1). + + labels -- a list of (x, y) pairs where x is either a token + number or a symbol number, and y is either None + or a string; the strings are keywords. The label + number is the index in this list; label numbers + are used to mark state transitions (arcs) in the + DFAs. + + start -- the number of the grammar's start symbol. + + keywords -- a dict mapping keyword strings to arc labels. + + tokens -- a dict mapping token numbers to arc labels. + + """ + + def __init__(self) -> None: + self.symbol2number: dict[str, int] = {} + self.number2symbol: dict[int, str] = {} + self.states: list[DFA] = [] + self.dfas: dict[int, DFAS] = {} + self.labels: list[Label] = [(0, "EMPTY")] + self.keywords: dict[str, int] = {} + self.soft_keywords: dict[str, int] = {} + self.tokens: dict[int, int] = {} + self.symbol2label: dict[str, int] = {} + self.version: tuple[int, int] = (0, 0) + self.start = 256 + # Python 3.7+ parses async as a keyword, not an identifier + self.async_keywords = False + + def dump(self, filename: Path) -> None: + """Dump the grammar tables to a pickle file.""" + + # mypyc generates objects that don't have a __dict__, but they + # do have __getstate__ methods that will return an equivalent + # dictionary + if hasattr(self, "__dict__"): + d = self.__dict__ + else: + d = self.__getstate__() # type: ignore + + with tempfile.NamedTemporaryFile( + dir=os.path.dirname(filename), delete=False + ) as f: + pickle.dump(d, f, pickle.HIGHEST_PROTOCOL) + os.replace(f.name, filename) + + def _update(self, attrs: dict[str, Any]) -> None: + for k, v in attrs.items(): + setattr(self, k, v) + + def load(self, filename: Path) -> None: + """Load the grammar tables from a pickle file.""" + with open(filename, "rb") as f: + d = pickle.load(f) + self._update(d) + + def loads(self, pkl: bytes) -> None: + """Load the grammar tables from a pickle bytes object.""" + self._update(pickle.loads(pkl)) + + def copy(self: _P) -> _P: + """ + Copy the grammar. + """ + new = self.__class__() + for dict_attr in ( + "symbol2number", + "number2symbol", + "dfas", + "keywords", + "soft_keywords", + "tokens", + "symbol2label", + ): + setattr(new, dict_attr, getattr(self, dict_attr).copy()) + new.labels = self.labels[:] + new.states = self.states[:] + new.start = self.start + new.version = self.version + new.async_keywords = self.async_keywords + return new + + def report(self) -> None: + """Dump the grammar tables to standard output, for debugging.""" + from pprint import pprint + + print("s2n") + pprint(self.symbol2number) + print("n2s") + pprint(self.number2symbol) + print("states") + pprint(self.states) + print("dfas") + pprint(self.dfas) + print("labels") + pprint(self.labels) + print("start", self.start) + + +# Map from operator to number (since tokenize doesn't do this) + +opmap_raw = """ +( LPAR +) RPAR +[ LSQB +] RSQB +: COLON +, COMMA +; SEMI ++ PLUS +- MINUS +* STAR +/ SLASH +| VBAR +& AMPER +< LESS +> GREATER += EQUAL +. DOT +% PERCENT +` BACKQUOTE +{ LBRACE +} RBRACE +@ AT +@= ATEQUAL +== EQEQUAL +!= NOTEQUAL +<> NOTEQUAL +<= LESSEQUAL +>= GREATEREQUAL +~ TILDE +^ CIRCUMFLEX +<< LEFTSHIFT +>> RIGHTSHIFT +** DOUBLESTAR ++= PLUSEQUAL +-= MINEQUAL +*= STAREQUAL +/= SLASHEQUAL +%= PERCENTEQUAL +&= AMPEREQUAL +|= VBAREQUAL +^= CIRCUMFLEXEQUAL +<<= LEFTSHIFTEQUAL +>>= RIGHTSHIFTEQUAL +**= DOUBLESTAREQUAL +// DOUBLESLASH +//= DOUBLESLASHEQUAL +-> RARROW +:= COLONEQUAL +! BANG +""" + +opmap = {} +for line in opmap_raw.splitlines(): + if line: + op, name = line.split() + opmap[op] = getattr(token, name) diff --git a/src/blib2to3/pgen2/literals.py b/src/blib2to3/pgen2/literals.py new file mode 100644 index 0000000..a384c08 --- /dev/null +++ b/src/blib2to3/pgen2/literals.py @@ -0,0 +1,65 @@ +# Copyright 2004-2005 Elemental Security, Inc. All Rights Reserved. +# Licensed to PSF under a Contributor Agreement. + +"""Safely evaluate Python string literals without using eval().""" + +import re + +simple_escapes: dict[str, str] = { + "a": "\a", + "b": "\b", + "f": "\f", + "n": "\n", + "r": "\r", + "t": "\t", + "v": "\v", + "'": "'", + '"': '"', + "\\": "\\", +} + + +def escape(m: re.Match[str]) -> str: + all, tail = m.group(0, 1) + assert all.startswith("\\") + esc = simple_escapes.get(tail) + if esc is not None: + return esc + if tail.startswith("x"): + hexes = tail[1:] + if len(hexes) < 2: + raise ValueError(f"invalid hex string escape ('\\{tail}')") + try: + i = int(hexes, 16) + except ValueError: + raise ValueError(f"invalid hex string escape ('\\{tail}')") from None + else: + try: + i = int(tail, 8) + except ValueError: + raise ValueError(f"invalid octal string escape ('\\{tail}')") from None + return chr(i) + + +def evalString(s: str) -> str: + assert s.startswith("'") or s.startswith('"'), repr(s[:1]) + q = s[0] + if s[:3] == q * 3: + q = q * 3 + assert s.endswith(q), repr(s[-len(q) :]) + assert len(s) >= 2 * len(q) + s = s[len(q) : -len(q)] + return re.sub(r"\\(\'|\"|\\|[abfnrtv]|x.{0,2}|[0-7]{1,3})", escape, s) + + +def test() -> None: + for i in range(256): + c = chr(i) + s = repr(c) + e = evalString(s) + if e != c: + print(i, c, s, e) + + +if __name__ == "__main__": + test() diff --git a/src/blib2to3/pgen2/parse.py b/src/blib2to3/pgen2/parse.py new file mode 100644 index 0000000..3ee003a --- /dev/null +++ b/src/blib2to3/pgen2/parse.py @@ -0,0 +1,395 @@ +# Copyright 2004-2005 Elemental Security, Inc. All Rights Reserved. +# Licensed to PSF under a Contributor Agreement. + +"""Parser engine for the grammar tables generated by pgen. + +The grammar table must be loaded first. + +See Parser/parser.c in the Python distribution for additional info on +how this parsing engine works. + +""" + +from collections.abc import Callable, Iterator +from contextlib import contextmanager +from typing import TYPE_CHECKING, Union, cast + +from blib2to3.pgen2.grammar import Grammar +from blib2to3.pytree import NL, Context, Leaf, Node, RawNode, convert + +# Local imports +from . import grammar, token, tokenize + +if TYPE_CHECKING: + from blib2to3.pgen2.driver import TokenProxy + + +Results = dict[str, NL] +Convert = Callable[[Grammar, RawNode], Union[Node, Leaf]] +DFA = list[list[tuple[int, int]]] +DFAS = tuple[DFA, dict[int, int]] + + +def lam_sub(grammar: Grammar, node: RawNode) -> NL: + assert node[3] is not None + return Node(type=node[0], children=node[3], context=node[2]) + + +# A placeholder node, used when parser is backtracking. +DUMMY_NODE = (-1, None, None, None) + + +def stack_copy( + stack: list[tuple[DFAS, int, RawNode]], +) -> list[tuple[DFAS, int, RawNode]]: + """Nodeless stack copy.""" + return [(dfa, label, DUMMY_NODE) for dfa, label, _ in stack] + + +class Recorder: + def __init__(self, parser: "Parser", ilabels: list[int], context: Context) -> None: + self.parser = parser + self._ilabels = ilabels + self.context = context # not really matter + + self._dead_ilabels: set[int] = set() + self._start_point = self.parser.stack + self._points = {ilabel: stack_copy(self._start_point) for ilabel in ilabels} + + @property + def ilabels(self) -> set[int]: + return self._dead_ilabels.symmetric_difference(self._ilabels) + + @contextmanager + def switch_to(self, ilabel: int) -> Iterator[None]: + with self.backtrack(): + self.parser.stack = self._points[ilabel] + try: + yield + except ParseError: + self._dead_ilabels.add(ilabel) + finally: + self.parser.stack = self._start_point + + @contextmanager + def backtrack(self) -> Iterator[None]: + """ + Use the node-level invariant ones for basic parsing operations (push/pop/shift). + These still will operate on the stack; but they won't create any new nodes, or + modify the contents of any other existing nodes. + + This saves us a ton of time when we are backtracking, since we + want to restore to the initial state as quick as possible, which + can only be done by having as little mutations as possible. + """ + is_backtracking = self.parser.is_backtracking + try: + self.parser.is_backtracking = True + yield + finally: + self.parser.is_backtracking = is_backtracking + + def add_token(self, tok_type: int, tok_val: str, raw: bool = False) -> None: + for ilabel in self.ilabels: + with self.switch_to(ilabel): + if raw: + self.parser._addtoken(ilabel, tok_type, tok_val, self.context) + else: + self.parser.addtoken(tok_type, tok_val, self.context) + + def determine_route( + self, value: str | None = None, force: bool = False + ) -> int | None: + alive_ilabels = self.ilabels + if len(alive_ilabels) == 0: + *_, most_successful_ilabel = self._dead_ilabels + raise ParseError("bad input", most_successful_ilabel, value, self.context) + + ilabel, *rest = alive_ilabels + if force or not rest: + return ilabel + else: + return None + + +class ParseError(Exception): + """Exception to signal the parser is stuck.""" + + def __init__( + self, msg: str, type: int | None, value: str | None, context: Context + ) -> None: + Exception.__init__( + self, f"{msg}: type={type!r}, value={value!r}, context={context!r}" + ) + self.msg = msg + self.type = type + self.value = value + self.context = context + + +class Parser: + """Parser engine. + + The proper usage sequence is: + + p = Parser(grammar, [converter]) # create instance + p.setup([start]) # prepare for parsing + : + if p.addtoken(...): # parse a token; may raise ParseError + break + root = p.rootnode # root of abstract syntax tree + + A Parser instance may be reused by calling setup() repeatedly. + + A Parser instance contains state pertaining to the current token + sequence, and should not be used concurrently by different threads + to parse separate token sequences. + + See driver.py for how to get input tokens by tokenizing a file or + string. + + Parsing is complete when addtoken() returns True; the root of the + abstract syntax tree can then be retrieved from the rootnode + instance variable. When a syntax error occurs, addtoken() raises + the ParseError exception. There is no error recovery; the parser + cannot be used after a syntax error was reported (but it can be + reinitialized by calling setup()). + + """ + + def __init__(self, grammar: Grammar, convert: Convert | None = None) -> None: + """Constructor. + + The grammar argument is a grammar.Grammar instance; see the + grammar module for more information. + + The parser is not ready yet for parsing; you must call the + setup() method to get it started. + + The optional convert argument is a function mapping concrete + syntax tree nodes to abstract syntax tree nodes. If not + given, no conversion is done and the syntax tree produced is + the concrete syntax tree. If given, it must be a function of + two arguments, the first being the grammar (a grammar.Grammar + instance), and the second being the concrete syntax tree node + to be converted. The syntax tree is converted from the bottom + up. + + **post-note: the convert argument is ignored since for Black's + usage, convert will always be blib2to3.pytree.convert. Allowing + this to be dynamic hurts mypyc's ability to use early binding. + These docs are left for historical and informational value. + + A concrete syntax tree node is a (type, value, context, nodes) + tuple, where type is the node type (a token or symbol number), + value is None for symbols and a string for tokens, context is + None or an opaque value used for error reporting (typically a + (lineno, offset) pair), and nodes is a list of children for + symbols, and None for tokens. + + An abstract syntax tree node may be anything; this is entirely + up to the converter function. + + """ + self.grammar = grammar + # See note in docstring above. TL;DR this is ignored. + self.convert = convert or lam_sub + self.is_backtracking = False + self.last_token: int | None = None + + def setup(self, proxy: "TokenProxy", start: int | None = None) -> None: + """Prepare for parsing. + + This *must* be called before starting to parse. + + The optional argument is an alternative start symbol; it + defaults to the grammar's start symbol. + + You can use a Parser instance to parse any number of programs; + each time you call setup() the parser is reset to an initial + state determined by the (implicit or explicit) start symbol. + + """ + if start is None: + start = self.grammar.start + # Each stack entry is a tuple: (dfa, state, node). + # A node is a tuple: (type, value, context, children), + # where children is a list of nodes or None, and context may be None. + newnode: RawNode = (start, None, None, []) + stackentry = (self.grammar.dfas[start], 0, newnode) + self.stack: list[tuple[DFAS, int, RawNode]] = [stackentry] + self.rootnode: NL | None = None + self.used_names: set[str] = set() + self.proxy = proxy + self.last_token = None + + def addtoken(self, type: int, value: str, context: Context) -> bool: + """Add a token; return True iff this is the end of the program.""" + # Map from token to label + ilabels = self.classify(type, value, context) + assert len(ilabels) >= 1 + + # If we have only one state to advance, we'll directly + # take it as is. + if len(ilabels) == 1: + [ilabel] = ilabels + return self._addtoken(ilabel, type, value, context) + + # If there are multiple states which we can advance (only + # happen under soft-keywords), then we will try all of them + # in parallel and as soon as one state can reach further than + # the rest, we'll choose that one. This is a pretty hacky + # and hopefully temporary algorithm. + # + # For a more detailed explanation, check out this post: + # https://tree.science/what-the-backtracking.html + + with self.proxy.release() as proxy: + counter, force = 0, False + recorder = Recorder(self, ilabels, context) + recorder.add_token(type, value, raw=True) + + next_token_value = value + while recorder.determine_route(next_token_value) is None: + if not proxy.can_advance(counter): + force = True + break + + next_token_type, next_token_value, *_ = proxy.eat(counter) + if next_token_type in (tokenize.COMMENT, tokenize.NL): + counter += 1 + continue + + if next_token_type == tokenize.OP: + next_token_type = grammar.opmap[next_token_value] + + recorder.add_token(next_token_type, next_token_value) + counter += 1 + + ilabel = cast(int, recorder.determine_route(next_token_value, force=force)) + assert ilabel is not None + + return self._addtoken(ilabel, type, value, context) + + def _addtoken(self, ilabel: int, type: int, value: str, context: Context) -> bool: + # Loop until the token is shifted; may raise exceptions + while True: + dfa, state, node = self.stack[-1] + states, first = dfa + arcs = states[state] + # Look for a state with this label + for i, newstate in arcs: + t = self.grammar.labels[i][0] + if t >= 256: + # See if it's a symbol and if we're in its first set + itsdfa = self.grammar.dfas[t] + itsstates, itsfirst = itsdfa + if ilabel in itsfirst: + # Push a symbol + self.push(t, itsdfa, newstate, context) + break # To continue the outer while loop + + elif ilabel == i: + # Look it up in the list of labels + # Shift a token; we're done with it + self.shift(type, value, newstate, context) + # Pop while we are in an accept-only state + state = newstate + while states[state] == [(0, state)]: + self.pop() + if not self.stack: + # Done parsing! + return True + dfa, state, node = self.stack[-1] + states, first = dfa + # Done with this token + self.last_token = type + return False + + else: + if (0, state) in arcs: + # An accepting state, pop it and try something else + self.pop() + if not self.stack: + # Done parsing, but another token is input + raise ParseError("too much input", type, value, context) + else: + # No success finding a transition + raise ParseError("bad input", type, value, context) + + def classify(self, type: int, value: str, context: Context) -> list[int]: + """Turn a token into a label. (Internal) + + Depending on whether the value is a soft-keyword or not, + this function may return multiple labels to choose from.""" + if type == token.NAME: + # Keep a listing of all used names + self.used_names.add(value) + # Check for reserved words + if value in self.grammar.keywords: + return [self.grammar.keywords[value]] + elif value in self.grammar.soft_keywords: + assert type in self.grammar.tokens + # Current soft keywords (match, case, type) can only appear at the + # beginning of a statement. So as a shortcut, don't try to treat them + # like keywords in any other context. + # ('_' is also a soft keyword in the real grammar, but for our grammar + # it's just an expression, so we don't need to treat it specially.) + if self.last_token not in ( + None, + token.INDENT, + token.DEDENT, + token.NEWLINE, + token.SEMI, + token.COLON, + ): + return [self.grammar.tokens[type]] + return [ + self.grammar.tokens[type], + self.grammar.soft_keywords[value], + ] + + ilabel = self.grammar.tokens.get(type) + if ilabel is None: + raise ParseError("bad token", type, value, context) + return [ilabel] + + def shift(self, type: int, value: str, newstate: int, context: Context) -> None: + """Shift a token. (Internal)""" + if self.is_backtracking: + dfa, state, _ = self.stack[-1] + self.stack[-1] = (dfa, newstate, DUMMY_NODE) + else: + dfa, state, node = self.stack[-1] + rawnode: RawNode = (type, value, context, None) + newnode = convert(self.grammar, rawnode) + assert node[-1] is not None + node[-1].append(newnode) + self.stack[-1] = (dfa, newstate, node) + + def push(self, type: int, newdfa: DFAS, newstate: int, context: Context) -> None: + """Push a nonterminal. (Internal)""" + if self.is_backtracking: + dfa, state, _ = self.stack[-1] + self.stack[-1] = (dfa, newstate, DUMMY_NODE) + self.stack.append((newdfa, 0, DUMMY_NODE)) + else: + dfa, state, node = self.stack[-1] + newnode: RawNode = (type, None, context, []) + self.stack[-1] = (dfa, newstate, node) + self.stack.append((newdfa, 0, newnode)) + + def pop(self) -> None: + """Pop a nonterminal. (Internal)""" + if self.is_backtracking: + self.stack.pop() + else: + popdfa, popstate, popnode = self.stack.pop() + newnode = convert(self.grammar, popnode) + if self.stack: + dfa, state, node = self.stack[-1] + assert node[-1] is not None + node[-1].append(newnode) + else: + self.rootnode = newnode + self.rootnode.used_names = self.used_names diff --git a/src/blib2to3/pgen2/pgen.py b/src/blib2to3/pgen2/pgen.py new file mode 100644 index 0000000..231dd91 --- /dev/null +++ b/src/blib2to3/pgen2/pgen.py @@ -0,0 +1,388 @@ +# Copyright 2004-2005 Elemental Security, Inc. All Rights Reserved. +# Licensed to PSF under a Contributor Agreement. + +import os +from collections.abc import Iterator, Sequence +from typing import IO, Any, NoReturn, Union + +from blib2to3.pgen2 import grammar, token, tokenize +from blib2to3.pgen2.tokenize import TokenInfo + +Path = Union[str, "os.PathLike[str]"] + + +class PgenGrammar(grammar.Grammar): + pass + + +class ParserGenerator: + filename: Path + stream: IO[str] + generator: Iterator[TokenInfo] + first: dict[str, dict[str, int] | None] + + def __init__(self, filename: Path, stream: IO[str] | None = None) -> None: + close_stream = None + if stream is None: + stream = open(filename, encoding="utf-8") + close_stream = stream.close + self.filename = filename + self.generator = tokenize.tokenize(stream.read()) + self.gettoken() # Initialize lookahead + self.dfas, self.startsymbol = self.parse() + if close_stream is not None: + close_stream() + self.first = {} # map from symbol name to set of tokens + self.addfirstsets() + + def make_grammar(self) -> PgenGrammar: + c = PgenGrammar() + names = list(self.dfas.keys()) + names.sort() + names.remove(self.startsymbol) + names.insert(0, self.startsymbol) + for name in names: + i = 256 + len(c.symbol2number) + c.symbol2number[name] = i + c.number2symbol[i] = name + for name in names: + dfa = self.dfas[name] + states = [] + for state in dfa: + arcs = [] + for label, next in sorted(state.arcs.items()): + arcs.append((self.make_label(c, label), dfa.index(next))) + if state.isfinal: + arcs.append((0, dfa.index(state))) + states.append(arcs) + c.states.append(states) + c.dfas[c.symbol2number[name]] = (states, self.make_first(c, name)) + c.start = c.symbol2number[self.startsymbol] + return c + + def make_first(self, c: PgenGrammar, name: str) -> dict[int, int]: + rawfirst = self.first[name] + assert rawfirst is not None + first = {} + for label in sorted(rawfirst): + ilabel = self.make_label(c, label) + ##assert ilabel not in first # XXX failed on <> ... != + first[ilabel] = 1 + return first + + def make_label(self, c: PgenGrammar, label: str) -> int: + # XXX Maybe this should be a method on a subclass of converter? + ilabel = len(c.labels) + if label[0].isalpha(): + # Either a symbol name or a named token + if label in c.symbol2number: + # A symbol name (a non-terminal) + if label in c.symbol2label: + return c.symbol2label[label] + else: + c.labels.append((c.symbol2number[label], None)) + c.symbol2label[label] = ilabel + return ilabel + else: + # A named token (NAME, NUMBER, STRING) + itoken = getattr(token, label, None) + assert isinstance(itoken, int), label + assert itoken in token.tok_name, label + if itoken in c.tokens: + return c.tokens[itoken] + else: + c.labels.append((itoken, None)) + c.tokens[itoken] = ilabel + return ilabel + else: + # Either a keyword or an operator + assert label[0] in ('"', "'"), label + value = eval(label) + if value[0].isalpha(): + if label[0] == '"': + keywords = c.soft_keywords + else: + keywords = c.keywords + + # A keyword + if value in keywords: + return keywords[value] + else: + c.labels.append((token.NAME, value)) + keywords[value] = ilabel + return ilabel + else: + # An operator (any non-numeric token) + itoken = grammar.opmap[value] # Fails if unknown token + if itoken in c.tokens: + return c.tokens[itoken] + else: + c.labels.append((itoken, None)) + c.tokens[itoken] = ilabel + return ilabel + + def addfirstsets(self) -> None: + names = list(self.dfas.keys()) + names.sort() + for name in names: + if name not in self.first: + self.calcfirst(name) + # print name, self.first[name].keys() + + def calcfirst(self, name: str) -> None: + dfa = self.dfas[name] + self.first[name] = None # dummy to detect left recursion + state = dfa[0] + totalset: dict[str, int] = {} + overlapcheck = {} + for label in state.arcs: + if label in self.dfas: + if label in self.first: + fset = self.first[label] + if fset is None: + raise ValueError(f"recursion for rule {name!r}") + else: + self.calcfirst(label) + fset = self.first[label] + assert fset is not None + totalset.update(fset) + overlapcheck[label] = fset + else: + totalset[label] = 1 + overlapcheck[label] = {label: 1} + inverse: dict[str, str] = {} + for label, itsfirst in overlapcheck.items(): + for symbol in itsfirst: + if symbol in inverse: + raise ValueError( + f"rule {name} is ambiguous; {symbol} is in the first sets of" + f" {label} as well as {inverse[symbol]}" + ) + inverse[symbol] = label + self.first[name] = totalset + + def parse(self) -> tuple[dict[str, list["DFAState"]], str]: + dfas = {} + startsymbol: str | None = None + # MSTART: (NEWLINE | RULE)* ENDMARKER + while self.type != token.ENDMARKER: + while self.type == token.NEWLINE: + self.gettoken() + # RULE: NAME ':' RHS NEWLINE + name = self.expect(token.NAME) + self.expect(token.OP, ":") + a, z = self.parse_rhs() + self.expect(token.NEWLINE) + # self.dump_nfa(name, a, z) + dfa = self.make_dfa(a, z) + # self.dump_dfa(name, dfa) + # oldlen = len(dfa) + self.simplify_dfa(dfa) + # newlen = len(dfa) + dfas[name] = dfa + # print name, oldlen, newlen + if startsymbol is None: + startsymbol = name + assert startsymbol is not None + return dfas, startsymbol + + def make_dfa(self, start: "NFAState", finish: "NFAState") -> list["DFAState"]: + # To turn an NFA into a DFA, we define the states of the DFA + # to correspond to *sets* of states of the NFA. Then do some + # state reduction. Let's represent sets as dicts with 1 for + # values. + assert isinstance(start, NFAState) + assert isinstance(finish, NFAState) + + def closure(state: NFAState) -> dict[NFAState, int]: + base: dict[NFAState, int] = {} + addclosure(state, base) + return base + + def addclosure(state: NFAState, base: dict[NFAState, int]) -> None: + assert isinstance(state, NFAState) + if state in base: + return + base[state] = 1 + for label, next in state.arcs: + if label is None: + addclosure(next, base) + + states = [DFAState(closure(start), finish)] + for state in states: # NB states grows while we're iterating + arcs: dict[str, dict[NFAState, int]] = {} + for nfastate in state.nfaset: + for label, next in nfastate.arcs: + if label is not None: + addclosure(next, arcs.setdefault(label, {})) + for label, nfaset in sorted(arcs.items()): + for st in states: + if st.nfaset == nfaset: + break + else: + st = DFAState(nfaset, finish) + states.append(st) + state.addarc(st, label) + return states # List of DFAState instances; first one is start + + def simplify_dfa(self, dfa: list["DFAState"]) -> None: + # This is not theoretically optimal, but works well enough. + # Algorithm: repeatedly look for two states that have the same + # set of arcs (same labels pointing to the same nodes) and + # unify them, until things stop changing. + + # dfa is a list of DFAState instances + changes = True + while changes: + changes = False + for i, state_i in enumerate(dfa): + for j in range(i + 1, len(dfa)): + state_j = dfa[j] + if state_i == state_j: + # print " unify", i, j + del dfa[j] + for state in dfa: + state.unifystate(state_j, state_i) + changes = True + break + + def parse_rhs(self) -> tuple["NFAState", "NFAState"]: + # RHS: ALT ('|' ALT)* + a, z = self.parse_alt() + if self.value != "|": + return a, z + else: + aa = NFAState() + zz = NFAState() + aa.addarc(a) + z.addarc(zz) + while self.value == "|": + self.gettoken() + a, z = self.parse_alt() + aa.addarc(a) + z.addarc(zz) + return aa, zz + + def parse_alt(self) -> tuple["NFAState", "NFAState"]: + # ALT: ITEM+ + a, b = self.parse_item() + while self.value in ("(", "[") or self.type in (token.NAME, token.STRING): + c, d = self.parse_item() + b.addarc(c) + b = d + return a, b + + def parse_item(self) -> tuple["NFAState", "NFAState"]: + # ITEM: '[' RHS ']' | ATOM ['+' | '*'] + if self.value == "[": + self.gettoken() + a, z = self.parse_rhs() + self.expect(token.OP, "]") + a.addarc(z) + return a, z + else: + a, z = self.parse_atom() + value = self.value + if value not in ("+", "*"): + return a, z + self.gettoken() + z.addarc(a) + if value == "+": + return a, z + else: + return a, a + + def parse_atom(self) -> tuple["NFAState", "NFAState"]: + # ATOM: '(' RHS ')' | NAME | STRING + if self.value == "(": + self.gettoken() + a, z = self.parse_rhs() + self.expect(token.OP, ")") + return a, z + elif self.type in (token.NAME, token.STRING): + a = NFAState() + z = NFAState() + a.addarc(z, self.value) + self.gettoken() + return a, z + else: + self.raise_error( + f"expected (...) or NAME or STRING, got {self.type}/{self.value}" + ) + + def expect(self, type: int, value: Any | None = None) -> str: + if self.type != type or (value is not None and self.value != value): + self.raise_error(f"expected {type}/{value}, got {self.type}/{self.value}") + value = self.value + self.gettoken() + return value + + def gettoken(self) -> None: + tup = next(self.generator) + while tup[0] in (tokenize.COMMENT, tokenize.NL): + tup = next(self.generator) + self.type, self.value, self.begin, self.end, self.line = tup + # print token.tok_name[self.type], repr(self.value) + + def raise_error(self, msg: str) -> NoReturn: + raise SyntaxError( + msg, (str(self.filename), self.end[0], self.end[1], self.line) + ) + + +class NFAState: + arcs: list[tuple[str | None, "NFAState"]] + + def __init__(self) -> None: + self.arcs = [] # list of (label, NFAState) pairs + + def addarc(self, next: "NFAState", label: str | None = None) -> None: + assert label is None or isinstance(label, str) + assert isinstance(next, NFAState) + self.arcs.append((label, next)) + + +class DFAState: + nfaset: dict[NFAState, Any] + isfinal: bool + arcs: dict[str, "DFAState"] + + def __init__(self, nfaset: dict[NFAState, Any], final: NFAState) -> None: + assert isinstance(nfaset, dict) + assert isinstance(next(iter(nfaset)), NFAState) + assert isinstance(final, NFAState) + self.nfaset = nfaset + self.isfinal = final in nfaset + self.arcs = {} # map from label to DFAState + + def addarc(self, next: "DFAState", label: str) -> None: + assert isinstance(label, str) + assert label not in self.arcs + assert isinstance(next, DFAState) + self.arcs[label] = next + + def unifystate(self, old: "DFAState", new: "DFAState") -> None: + for label, next in self.arcs.items(): + if next is old: + self.arcs[label] = new + + def __eq__(self, other: Any) -> bool: + # Equality test -- ignore the nfaset instance variable + assert isinstance(other, DFAState) + if self.isfinal != other.isfinal: + return False + # Can't just return self.arcs == other.arcs, because that + # would invoke this method recursively, with cycles... + if len(self.arcs) != len(other.arcs): + return False + for label, next in self.arcs.items(): + if next is not other.arcs.get(label): + return False + return True + + __hash__: Any = None # For Py3 compatibility. + + +def generate_grammar(filename: Path = "Grammar.txt") -> PgenGrammar: + p = ParserGenerator(filename) + return p.make_grammar() diff --git a/src/blib2to3/pgen2/token.py b/src/blib2to3/pgen2/token.py new file mode 100644 index 0000000..80aca56 --- /dev/null +++ b/src/blib2to3/pgen2/token.py @@ -0,0 +1,84 @@ +"""Token constants (from "token.h").""" + +from typing import Final + +# Taken from Python (r53757) and modified to include some tokens +# originally monkeypatched in by pgen2.tokenize + +# --start constants-- +ENDMARKER: Final = 0 +NAME: Final = 1 +NUMBER: Final = 2 +STRING: Final = 3 +NEWLINE: Final = 4 +INDENT: Final = 5 +DEDENT: Final = 6 +LPAR: Final = 7 +RPAR: Final = 8 +LSQB: Final = 9 +RSQB: Final = 10 +COLON: Final = 11 +COMMA: Final = 12 +SEMI: Final = 13 +PLUS: Final = 14 +MINUS: Final = 15 +STAR: Final = 16 +SLASH: Final = 17 +VBAR: Final = 18 +AMPER: Final = 19 +LESS: Final = 20 +GREATER: Final = 21 +EQUAL: Final = 22 +DOT: Final = 23 +PERCENT: Final = 24 +BACKQUOTE: Final = 25 +LBRACE: Final = 26 +RBRACE: Final = 27 +EQEQUAL: Final = 28 +NOTEQUAL: Final = 29 +LESSEQUAL: Final = 30 +GREATEREQUAL: Final = 31 +TILDE: Final = 32 +CIRCUMFLEX: Final = 33 +LEFTSHIFT: Final = 34 +RIGHTSHIFT: Final = 35 +DOUBLESTAR: Final = 36 +PLUSEQUAL: Final = 37 +MINEQUAL: Final = 38 +STAREQUAL: Final = 39 +SLASHEQUAL: Final = 40 +PERCENTEQUAL: Final = 41 +AMPEREQUAL: Final = 42 +VBAREQUAL: Final = 43 +CIRCUMFLEXEQUAL: Final = 44 +LEFTSHIFTEQUAL: Final = 45 +RIGHTSHIFTEQUAL: Final = 46 +DOUBLESTAREQUAL: Final = 47 +DOUBLESLASH: Final = 48 +DOUBLESLASHEQUAL: Final = 49 +AT: Final = 50 +ATEQUAL: Final = 51 +OP: Final = 52 +COMMENT: Final = 53 +NL: Final = 54 +RARROW: Final = 55 +AWAIT: Final = 56 +ASYNC: Final = 57 +LAZY: Final = 58 +ERRORTOKEN: Final = 59 +COLONEQUAL: Final = 60 +FSTRING_START: Final = 61 +FSTRING_MIDDLE: Final = 62 +FSTRING_END: Final = 63 +BANG: Final = 64 +TSTRING_START: Final = 65 +TSTRING_MIDDLE: Final = 66 +TSTRING_END: Final = 67 +N_TOKENS: Final = 68 +NT_OFFSET: Final = 256 +# --end constants-- + +tok_name: Final[dict[int, str]] = {} +for _name, _value in list(globals().items()): + if type(_value) is int: + tok_name[_value] = _name diff --git a/src/blib2to3/pgen2/tokenize.py b/src/blib2to3/pgen2/tokenize.py new file mode 100644 index 0000000..45423fc --- /dev/null +++ b/src/blib2to3/pgen2/tokenize.py @@ -0,0 +1,277 @@ +# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006 Python Software Foundation. +# All rights reserved. + +# mypy: allow-untyped-defs, allow-untyped-calls + +"""Tokenization help for Python programs. + +generate_tokens(readline) is a generator that breaks a stream of +text into Python tokens. It accepts a readline-like method which is called +repeatedly to get the next line of input (or "" for EOF). It generates +5-tuples with these members: + + the token type (see token.py) + the token (a string) + the starting (row, column) indices of the token (a 2-tuple of ints) + the ending (row, column) indices of the token (a 2-tuple of ints) + the original line (string) + +It is designed to match the working of the Python tokenizer exactly, except +that it produces COMMENT tokens for comments and gives type OP for all +operators + +Older entry points + tokenize_loop(readline, tokeneater) + tokenize(readline, tokeneater=printtoken) +are the same, except instead of generating tokens, tokeneater is a callback +function to which the 5 fields described above are passed as 5 arguments, +each time a new token is found.""" + +import sys +from collections.abc import Iterator + +from blib2to3.pgen2.grammar import Grammar +from blib2to3.pgen2.token import ( + ASYNC, + AWAIT, + COMMENT, + DEDENT, + ENDMARKER, + FSTRING_END, + FSTRING_MIDDLE, + FSTRING_START, + INDENT, + LAZY, + NAME, + NEWLINE, + NL, + NUMBER, + OP, + STRING, + TSTRING_END, + TSTRING_MIDDLE, + TSTRING_START, + tok_name, +) + +__author__ = "Ka-Ping Yee " +__credits__ = "GvR, ESR, Tim Peters, Thomas Wouters, Fred Drake, Skip Montanaro" + +import pytokens +from pytokens import TokenType + +from . import token as _token + +__all__ = [x for x in dir(_token) if x[0] != "_"] + [ + "tokenize", + "generate_tokens", + "untokenize", +] +del _token + +Coord = tuple[int, int] +TokenInfo = tuple[int, str, Coord, Coord, str] +LazyStash = tuple[pytokens.Token, str, str] + +TOKEN_TYPE_MAP = { + TokenType.indent: INDENT, + TokenType.dedent: DEDENT, + TokenType.newline: NEWLINE, + TokenType.nl: NL, + TokenType.comment: COMMENT, + TokenType.semicolon: OP, + TokenType.lparen: OP, + TokenType.rparen: OP, + TokenType.lbracket: OP, + TokenType.rbracket: OP, + TokenType.lbrace: OP, + TokenType.rbrace: OP, + TokenType.colon: OP, + TokenType.op: OP, + TokenType.identifier: NAME, + TokenType.number: NUMBER, + TokenType.string: STRING, + TokenType.fstring_start: FSTRING_START, + TokenType.fstring_middle: FSTRING_MIDDLE, + TokenType.fstring_end: FSTRING_END, + TokenType.tstring_start: TSTRING_START, + TokenType.tstring_middle: TSTRING_MIDDLE, + TokenType.tstring_end: TSTRING_END, + TokenType.endmarker: ENDMARKER, +} + + +class TokenError(Exception): ... + + +def transform_whitespace( + token: pytokens.Token, source: str, prev_token: pytokens.Token | None +) -> pytokens.Token: + r""" + Black treats `\\\n` at the end of a line as a 'NL' token, while it + is ignored as whitespace in the regular Python parser. + But, only the first one. If there's a `\\\n` following it + (as in, a \ just by itself on a line), that is not made into NL. + """ + if ( + token.type == TokenType.whitespace + and prev_token is not None + and prev_token.type not in (TokenType.nl, TokenType.newline) + ): + token_str = source[token.start_index : token.end_index] + if token_str.startswith("\\\r\n"): + return pytokens.Token( + TokenType.nl, + token.start_index, + token.start_index + 3, + token.start_line, + token.start_col, + token.start_line, + token.start_col + 3, + ) + elif token_str.startswith("\\\n") or token_str.startswith("\\\r"): + return pytokens.Token( + TokenType.nl, + token.start_index, + token.start_index + 2, + token.start_line, + token.start_col, + token.start_line, + token.start_col + 2, + ) + + return token + + +def tokenize(source: str, grammar: Grammar | None = None) -> Iterator[TokenInfo]: + lines = source.split("\n") + lines += [""] # For newline tokens in files that don't end in a newline + line, column = 1, 0 + + prev_token: pytokens.Token | None = None + lazy_stashed: LazyStash | None = None + stmt_start = True + + def emit_stashed_lazy(*, as_keyword: bool) -> Iterator[TokenInfo]: + nonlocal lazy_stashed + if lazy_stashed is None: + return + + stashed_token, stashed_str, stashed_line = lazy_stashed + yield ( + LAZY if as_keyword else NAME, + stashed_str, + (stashed_token.start_line, stashed_token.start_col), + (stashed_token.end_line, stashed_token.end_col), + stashed_line, + ) + lazy_stashed = None + + try: + for token in pytokens.tokenize(source): + token = transform_whitespace(token, source, prev_token) + + line, column = token.start_line, token.start_col + if token.type == TokenType.whitespace: + continue + + token_str = source[token.start_index : token.end_index] + + if token.type == TokenType.newline and token_str == "": + # Black doesn't yield empty newline tokens at the end of a file + # if there's no newline at the end of a file. + prev_token = token + continue + + source_line = lines[token.start_line - 1] + + if lazy_stashed is not None and not ( + token.type == TokenType.identifier and token_str in ("import", "from") + ): + yield from emit_stashed_lazy(as_keyword=False) + + if ( + token.type == TokenType.identifier + and token_str == "lazy" + and stmt_start + ): + lazy_stashed = (token, token_str, source_line) + prev_token = token + stmt_start = False + continue + + if lazy_stashed is not None: + yield from emit_stashed_lazy(as_keyword=True) + + if token.type == TokenType.identifier and token_str in ("async", "await"): + # Black uses `async` and `await` token types just for those two keywords + yield ( + ASYNC if token_str == "async" else AWAIT, + token_str, + (token.start_line, token.start_col), + (token.end_line, token.end_col), + source_line, + ) + elif token.type == TokenType.op and token_str == "...": + # Black doesn't have an ellipsis token yet, yield 3 DOTs instead + assert token.start_line == token.end_line + assert token.end_col == token.start_col + 3 + + token_str = "." + for start_col in range(token.start_col, token.start_col + 3): + end_col = start_col + 1 + yield ( + TOKEN_TYPE_MAP[token.type], + token_str, + (token.start_line, start_col), + (token.end_line, end_col), + source_line, + ) + else: + token_type = TOKEN_TYPE_MAP.get(token.type) + if token_type is None: + raise ValueError(f"Unknown token type: {token.type!r}") + yield ( + TOKEN_TYPE_MAP[token.type], + token_str, + (token.start_line, token.start_col), + (token.end_line, token.end_col), + source_line, + ) + prev_token = token + + if token.type in { + TokenType.indent, + TokenType.dedent, + TokenType.newline, + TokenType.semicolon, + TokenType.colon, + }: + stmt_start = True + elif token.type not in {TokenType.comment, TokenType.nl}: + stmt_start = False + + yield from emit_stashed_lazy(as_keyword=False) + + except pytokens.UnexpectedEOF: + raise TokenError("Unexpected EOF in multi-line statement", (line, column)) + except pytokens.TokenizeError as exc: + raise TokenError(f"Failed to parse: {type(exc).__name__}", (line, column)) + + +def printtoken( + type: int, token: str, srow_col: Coord, erow_col: Coord, line: str +) -> None: # for testing + srow, scol = srow_col + erow, ecol = erow_col + print(f"{srow},{scol}-{erow},{ecol}:\t{tok_name[type]}\t{token!r}") + + +if __name__ == "__main__": # testing + if len(sys.argv) > 1: + token_iterator = tokenize(open(sys.argv[1]).read()) + else: + token_iterator = tokenize(sys.stdin.read()) + + for tok in token_iterator: + printtoken(*tok) diff --git a/src/blib2to3/pygram.py b/src/blib2to3/pygram.py new file mode 100644 index 0000000..ebe5edf --- /dev/null +++ b/src/blib2to3/pygram.py @@ -0,0 +1,209 @@ +# Copyright 2006 Google, Inc. All Rights Reserved. +# Licensed to PSF under a Contributor Agreement. + +"""Export the Python grammar and symbols.""" + +# Python imports +import os +from typing import Union + +# Local imports +from .pgen2 import driver +from .pgen2.grammar import Grammar + +# Moved into initialize because mypyc can't handle __file__ (XXX bug) +# # The grammar file +# _GRAMMAR_FILE = os.path.join(os.path.dirname(__file__), "Grammar.txt") +# _PATTERN_GRAMMAR_FILE = os.path.join(os.path.dirname(__file__), +# "PatternGrammar.txt") + + +class Symbols: + def __init__(self, grammar: Grammar) -> None: + """Initializer. + + Creates an attribute for each grammar symbol (nonterminal), + whose value is the symbol's type (an int >= 256). + """ + for name, symbol in grammar.symbol2number.items(): + setattr(self, name, symbol) + + +class _python_symbols(Symbols): + and_expr: int + and_test: int + annassign: int + arglist: int + argument: int + arith_expr: int + asexpr_test: int + assert_stmt: int + async_funcdef: int + async_stmt: int + atom: int + augassign: int + break_stmt: int + case_block: int + classdef: int + comp_for: int + comp_if: int + comp_iter: int + comp_op: int + comparison: int + compound_stmt: int + continue_stmt: int + decorated: int + decorator: int + decorators: int + del_stmt: int + dictsetmaker: int + dotted_as_name: int + dotted_as_names: int + dotted_name: int + encoding_decl: int + eval_input: int + except_clause: int + expr: int + expr_stmt: int + exprlist: int + factor: int + file_input: int + flow_stmt: int + for_stmt: int + fstring: int + fstring_format_spec: int + fstring_middle: int + fstring_replacement_field: int + funcdef: int + global_stmt: int + guard: int + if_stmt: int + import_as_name: int + import_as_names: int + import_from: int + import_name: int + import_stmt: int + lazy_import: int + lambdef: int + listmaker: int + match_stmt: int + namedexpr_test: int + not_test: int + old_comp_for: int + old_comp_if: int + old_comp_iter: int + old_lambdef: int + old_test: int + or_test: int + parameters: int + paramspec: int + pass_stmt: int + pattern: int + patterns: int + power: int + raise_stmt: int + return_stmt: int + shift_expr: int + simple_stmt: int + single_input: int + sliceop: int + small_stmt: int + subject_expr: int + star_expr: int + stmt: int + subscript: int + subscriptlist: int + suite: int + term: int + test: int + testlist: int + testlist1: int + testlist_gexp: int + testlist_safe: int + testlist_star_expr: int + tfpdef: int + tfplist: int + tname: int + tname_star: int + trailer: int + try_stmt: int + tstring: int + tstring_format_spec: int + tstring_middle: int + tstring_replacement_field: int + type_stmt: int + typedargslist: int + typeparam: int + typeparams: int + typevar: int + typevartuple: int + varargslist: int + vfpdef: int + vfplist: int + vname: int + while_stmt: int + with_stmt: int + xor_expr: int + yield_arg: int + yield_expr: int + yield_stmt: int + + +class _pattern_symbols(Symbols): + Alternative: int + Alternatives: int + Details: int + Matcher: int + NegatedUnit: int + Repeater: int + Unit: int + + +python_grammar: Grammar +python_grammar_async_keywords: Grammar +python_grammar_soft_keywords: Grammar +pattern_grammar: Grammar +python_symbols: _python_symbols +pattern_symbols: _pattern_symbols + + +def initialize(cache_dir: Union[str, "os.PathLike[str]", None] = None) -> None: + global python_grammar + global python_grammar_async_keywords + global python_grammar_soft_keywords + global python_symbols + global pattern_grammar + global pattern_symbols + + # The grammar file + _GRAMMAR_FILE = os.path.join(os.path.dirname(__file__), "Grammar.txt") + _PATTERN_GRAMMAR_FILE = os.path.join( + os.path.dirname(__file__), "PatternGrammar.txt" + ) + + python_grammar = driver.load_packaged_grammar("blib2to3", _GRAMMAR_FILE, cache_dir) + assert "print" not in python_grammar.keywords + assert "exec" not in python_grammar.keywords + + soft_keywords = python_grammar.soft_keywords.copy() + python_grammar.soft_keywords.clear() + + python_symbols = _python_symbols(python_grammar) + + # Python 3.0-3.6 + python_grammar.version = (3, 0) + + # Python 3.7+ + python_grammar_async_keywords = python_grammar.copy() + python_grammar_async_keywords.async_keywords = True + python_grammar_async_keywords.version = (3, 7) + + # Python 3.10+ + python_grammar_soft_keywords = python_grammar_async_keywords.copy() + python_grammar_soft_keywords.soft_keywords = soft_keywords + python_grammar_soft_keywords.version = (3, 10) + + pattern_grammar = driver.load_packaged_grammar( + "blib2to3", _PATTERN_GRAMMAR_FILE, cache_dir + ) + pattern_symbols = _pattern_symbols(pattern_grammar) diff --git a/src/blib2to3/pytree.py b/src/blib2to3/pytree.py new file mode 100644 index 0000000..203d12a --- /dev/null +++ b/src/blib2to3/pytree.py @@ -0,0 +1,1054 @@ +# Copyright 2006 Google, Inc. All Rights Reserved. +# Licensed to PSF under a Contributor Agreement. + +""" +Python parse tree definitions. + +This is a very concrete parse tree; we need to keep every token and +even the comments and whitespace between tokens. + +There's also a pattern matching implementation here. +""" + +# mypy: allow-untyped-defs, allow-incomplete-defs + +from collections.abc import Iterable, Iterator +from typing import Any, Optional, TypeVar, Union + +from blib2to3.pgen2.grammar import Grammar + +__author__ = "Guido van Rossum " + +import sys +from io import StringIO + +HUGE: int = 0x7FFFFFFF # maximum repeat count, default max + +_type_reprs: dict[int, str | int] = {} + + +def type_repr(type_num: int) -> str | int: + global _type_reprs + if not _type_reprs: + from . import pygram + + if not hasattr(pygram, "python_symbols"): + pygram.initialize(cache_dir=None) + + # printing tokens is possible but not as useful + # from .pgen2 import token // token.__dict__.items(): + for name in dir(pygram.python_symbols): + val = getattr(pygram.python_symbols, name) + if type(val) == int: + _type_reprs[val] = name + return _type_reprs.setdefault(type_num, type_num) + + +_P = TypeVar("_P", bound="Base") + +NL = Union["Node", "Leaf"] +Context = tuple[str, tuple[int, int]] +RawNode = tuple[int, Optional[str], Optional[Context], Optional[list[NL]]] + + +class Base: + """ + Abstract base class for Node and Leaf. + + This provides some default functionality and boilerplate using the + template pattern. + + A node may be a subnode of at most one parent. + """ + + # Default values for instance variables + type: int # int: token number (< 256) or symbol number (>= 256) + parent: Optional["Node"] = None # Parent node pointer, or None + children: list[NL] # List of subnodes + was_changed: bool = False + + def __new__(cls, *args, **kwds): + """Constructor that prevents Base from being instantiated.""" + assert cls is not Base, "Cannot instantiate Base" + return object.__new__(cls) + + def __eq__(self, other: Any) -> bool: + """ + Compare two nodes for equality. + + This calls the method _eq(). + """ + if self.__class__ is not other.__class__: + return NotImplemented + return self._eq(other) + + @property + def prefix(self) -> str: + raise NotImplementedError + + def _eq(self: _P, other: _P) -> bool: + """ + Compare two nodes for equality. + + This is called by __eq__ and __ne__. It is only called if the two nodes + have the same type. This must be implemented by the concrete subclass. + Nodes should be considered equal if they have the same structure, + ignoring the prefix string and other context information. + """ + raise NotImplementedError + + def __deepcopy__(self: _P, memo: Any) -> _P: + return self.clone() + + def clone(self: _P) -> _P: + """ + Return a cloned (deep) copy of self. + + This must be implemented by the concrete subclass. + """ + raise NotImplementedError + + def post_order(self) -> Iterator[NL]: + """ + Return a post-order iterator for the tree. + + This must be implemented by the concrete subclass. + """ + raise NotImplementedError + + def pre_order(self) -> Iterator[NL]: + """ + Return a pre-order iterator for the tree. + + This must be implemented by the concrete subclass. + """ + raise NotImplementedError + + def replace(self, new: NL | list[NL]) -> None: + """Replace this node with a new one in the parent.""" + assert self.parent is not None, str(self) + assert new is not None + if not isinstance(new, list): + new = [new] + parent = self.parent + for i, ch in enumerate(parent.children): + if ch is self: + break + else: + raise AssertionError((parent.children, self, new)) + # Splice the new children in place of `self` and keep the cached sibling + # maps valid without rebuilding them, which would be O(len(children)) per + # call and quadratic when many children are replaced while siblings are + # read in between (e.g. merging implicitly concatenated strings). + parent._replace_child_in_sibling_maps(self, new) + parent.children[i : i + 1] = new + parent.changed() + for x in new: + x.parent = parent + self.parent = None + + def get_lineno(self) -> int | None: + """Return the line number which generated the invocant node.""" + node = self + while not isinstance(node, Leaf): + if not node.children: + return None + node = node.children[0] + return node.lineno + + def changed(self) -> None: + if self.was_changed: + return + if self.parent: + self.parent.changed() + self.was_changed = True + + def remove(self, search_start: int = 0) -> int | None: + """ + Remove the node from the tree. Returns the position of the node in its + parent's children before it was removed. + + ``search_start`` hints where to begin looking in the parent's children. + A caller that removes many siblings of the same parent in left-to-right + order can pass the last returned position to avoid rescanning the whole + list from index 0 every time, which is quadratic over the parent. The + entire list is still searched (starting at the hint and wrapping around), + so an inaccurate hint only costs a little extra scanning. + """ + if self.parent: + children = self.parent.children + count = len(children) + for offset in range(count): + i = (search_start + offset) % count + if children[i] is self: + del children[i] + self.parent.changed() + self.parent._remove_from_sibling_maps(self) + self.parent = None + return i + return None + + @property + def next_sibling(self) -> NL | None: + """ + The node immediately following the invocant in their parent's children + list. If the invocant does not have a next sibling, it is None + """ + if self.parent is None: + return None + + if self.parent.next_sibling_map is None: + self.parent.update_sibling_maps() + assert self.parent.next_sibling_map is not None + return self.parent.next_sibling_map[id(self)] + + @property + def prev_sibling(self) -> NL | None: + """ + The node immediately preceding the invocant in their parent's children + list. If the invocant does not have a previous sibling, it is None. + """ + if self.parent is None: + return None + + if self.parent.prev_sibling_map is None: + self.parent.update_sibling_maps() + assert self.parent.prev_sibling_map is not None + return self.parent.prev_sibling_map[id(self)] + + def leaves(self) -> Iterator["Leaf"]: + for child in self.children: + yield from child.leaves() + + def depth(self) -> int: + if self.parent is None: + return 0 + return 1 + self.parent.depth() + + def get_suffix(self) -> str: + """ + Return the string immediately following the invocant node. This is + effectively equivalent to node.next_sibling.prefix + """ + next_sib = self.next_sibling + if next_sib is None: + return "" + prefix = next_sib.prefix + return prefix + + +class Node(Base): + """Concrete implementation for interior nodes.""" + + fixers_applied: list[Any] | None + used_names: set[str] | None + + def __init__( + self, + type: int, + children: list[NL], + context: Any | None = None, + prefix: str | None = None, + fixers_applied: list[Any] | None = None, + ) -> None: + """ + Initializer. + + Takes a type constant (a symbol number >= 256), a sequence of + child nodes, and an optional context keyword argument. + + As a side effect, the parent pointers of the children are updated. + """ + assert type >= 256, type + self.type = type + self.children = list(children) + for ch in self.children: + assert ch.parent is None, repr(ch) + ch.parent = self + self.invalidate_sibling_maps() + if prefix is not None: + self.prefix = prefix + if fixers_applied: + self.fixers_applied = fixers_applied[:] + else: + self.fixers_applied = None + + def __repr__(self) -> str: + """Return a canonical string representation.""" + assert self.type is not None + return f"{self.__class__.__name__}({type_repr(self.type)}, {self.children!r})" + + def __str__(self) -> str: + """ + Return a pretty string representation. + + This reproduces the input source exactly. + """ + return "".join(map(str, self.children)) + + def _eq(self, other: Base) -> bool: + """Compare two nodes for equality.""" + return (self.type, self.children) == (other.type, other.children) + + def clone(self) -> "Node": + assert self.type is not None + """Return a cloned (deep) copy of self.""" + return Node( + self.type, + [ch.clone() for ch in self.children], + fixers_applied=self.fixers_applied, + ) + + def post_order(self) -> Iterator[NL]: + """Return a post-order iterator for the tree.""" + for child in self.children: + yield from child.post_order() + yield self + + def pre_order(self) -> Iterator[NL]: + """Return a pre-order iterator for the tree.""" + yield self + for child in self.children: + yield from child.pre_order() + + @property + def prefix(self) -> str: + """ + The whitespace and comments preceding this node in the input. + """ + if not self.children: + return "" + return self.children[0].prefix + + @prefix.setter + def prefix(self, prefix: str) -> None: + if self.children: + self.children[0].prefix = prefix + + def set_child(self, i: int, child: NL) -> None: + """ + Equivalent to 'node.children[i] = child'. This method also sets the + child's parent attribute appropriately. + """ + child.parent = self + old = self.children[i] + old.parent = None + self.children[i] = child + self.changed() + self._replace_in_sibling_maps(old, child) + + def insert_child(self, i: int, child: NL) -> None: + """ + Equivalent to 'node.children.insert(i, child)'. This method also sets + the child's parent attribute appropriately. + """ + child.parent = self + self.children.insert(i, child) + self.changed() + if 0 <= i < len(self.children) and self.children[i] is child: + self._insert_into_sibling_maps(i, child) + else: + self.invalidate_sibling_maps() + + def append_child(self, child: NL) -> None: + """ + Equivalent to 'node.children.append(child)'. This method also sets the + child's parent attribute appropriately. + """ + child.parent = self + self.children.append(child) + self.changed() + self._insert_into_sibling_maps(len(self.children) - 1, child) + + def invalidate_sibling_maps(self) -> None: + self.prev_sibling_map: dict[int, NL | None] | None = None + self.next_sibling_map: dict[int, NL | None] | None = None + + def _insert_into_sibling_maps(self, i: int, child: NL) -> None: + """Splice a newly inserted child into the cached sibling maps. + + Keeps the maps valid without rebuilding them from scratch, which would + be O(len(children)) per call and quadratic when many children are + inserted while siblings are read in between (e.g. ``append_leaves``). + """ + prev_map = self.prev_sibling_map + next_map = self.next_sibling_map + if prev_map is None or next_map is None: + return + before = self.children[i - 1] if i > 0 else None + after = self.children[i + 1] if i + 1 < len(self.children) else None + prev_map[id(child)] = before + next_map[id(child)] = after + next_map[id(before)] = child + if after is not None: + prev_map[id(after)] = child + + def _remove_from_sibling_maps(self, child: NL) -> None: + """Splice a removed child out of the cached sibling maps.""" + prev_map = self.prev_sibling_map + next_map = self.next_sibling_map + if prev_map is None or next_map is None: + return + if id(child) not in prev_map: + self.invalidate_sibling_maps() + return + before = prev_map.pop(id(child)) + after = next_map.pop(id(child)) + next_map[id(before)] = after + if after is not None: + prev_map[id(after)] = before + + def _replace_in_sibling_maps(self, old: NL, child: NL) -> None: + """Swap ``old`` for ``child`` at the same position in the sibling maps.""" + prev_map = self.prev_sibling_map + next_map = self.next_sibling_map + if prev_map is None or next_map is None: + return + if id(old) not in prev_map: + self.invalidate_sibling_maps() + return + before = prev_map.pop(id(old)) + after = next_map.pop(id(old)) + prev_map[id(child)] = before + next_map[id(child)] = after + next_map[id(before)] = child + if after is not None: + prev_map[id(after)] = child + + def _replace_child_in_sibling_maps(self, old: NL, new_children: list[NL]) -> None: + """Swap ``old`` for ``new_children`` at the same position in the maps.""" + prev_map = self.prev_sibling_map + next_map = self.next_sibling_map + if prev_map is None or next_map is None: + return + if id(old) not in prev_map: + self.invalidate_sibling_maps() + return + before = prev_map.pop(id(old)) + after = next_map.pop(id(old)) + previous = before + for child in new_children: + prev_map[id(child)] = previous + next_map[id(previous)] = child + previous = child + next_map[id(previous)] = after + if after is not None: + prev_map[id(after)] = previous + + def update_sibling_maps(self) -> None: + _prev: dict[int, NL | None] = {} + _next: dict[int, NL | None] = {} + self.prev_sibling_map = _prev + self.next_sibling_map = _next + previous: NL | None = None + for current in self.children: + _prev[id(current)] = previous + _next[id(previous)] = current + previous = current + _next[id(current)] = None + + +class Leaf(Base): + """Concrete implementation for leaf nodes.""" + + # Default values for instance variables + value: str + fixers_applied: list[Any] + bracket_depth: int + # Changed later in brackets.py + opening_bracket: Optional["Leaf"] = None + used_names: set[str] | None + _prefix = "" # Whitespace and comments preceding this token in the input + lineno: int = 0 # Line where this token starts in the input + column: int = 0 # Column where this token starts in the input + # If not None, this Leaf is created by converting a block of fmt off/skip + # code, and `fmt_pass_converted_first_leaf` points to the first Leaf in the + # converted code. + fmt_pass_converted_first_leaf: Optional["Leaf"] = None + + def __init__( + self, + type: int, + value: str, + context: Context | None = None, + prefix: str | None = None, + fixers_applied: list[Any] = [], + opening_bracket: Optional["Leaf"] = None, + fmt_pass_converted_first_leaf: Optional["Leaf"] = None, + ) -> None: + """ + Initializer. + + Takes a type constant (a token number < 256), a string value, and an + optional context keyword argument. + """ + + assert 0 <= type < 256, type + if context is not None: + self._prefix, (self.lineno, self.column) = context + self.type = type + self.value = value + if prefix is not None: + self._prefix = prefix + self.fixers_applied: list[Any] | None = fixers_applied[:] + self.children = [] + self.opening_bracket = opening_bracket + self.fmt_pass_converted_first_leaf = fmt_pass_converted_first_leaf + + def __repr__(self) -> str: + """Return a canonical string representation.""" + from .pgen2.token import tok_name + + assert self.type is not None + return ( + f"{self.__class__.__name__}({tok_name.get(self.type, self.type)}," + f" {self.value!r})" + ) + + def __str__(self) -> str: + """ + Return a pretty string representation. + + This reproduces the input source exactly. + """ + return self._prefix + str(self.value) + + def _eq(self, other: "Leaf") -> bool: + """Compare two nodes for equality.""" + return (self.type, self.value) == (other.type, other.value) + + def clone(self) -> "Leaf": + assert self.type is not None + """Return a cloned (deep) copy of self.""" + return Leaf( + self.type, + self.value, + (self.prefix, (self.lineno, self.column)), + fixers_applied=self.fixers_applied, + ) + + def leaves(self) -> Iterator["Leaf"]: + yield self + + def post_order(self) -> Iterator["Leaf"]: + """Return a post-order iterator for the tree.""" + yield self + + def pre_order(self) -> Iterator["Leaf"]: + """Return a pre-order iterator for the tree.""" + yield self + + @property + def prefix(self) -> str: + """ + The whitespace and comments preceding this token in the input. + """ + return self._prefix + + @prefix.setter + def prefix(self, prefix: str) -> None: + self.changed() + self._prefix = prefix + + +def convert(gr: Grammar, raw_node: RawNode) -> NL: + """ + Convert raw node information to a Node or Leaf instance. + + This is passed to the parser driver which calls it whenever a reduction of a + grammar rule produces a new complete node, so that the tree is build + strictly bottom-up. + """ + type, value, context, children = raw_node + if children or type in gr.number2symbol: + # If there's exactly one child, return that child instead of + # creating a new node. + assert children is not None + if len(children) == 1: + return children[0] + return Node(type, children, context=context) + else: + return Leaf(type, value or "", context=context) + + +_Results = dict[str, NL] + + +class BasePattern: + """ + A pattern is a tree matching pattern. + + It looks for a specific node type (token or symbol), and + optionally for a specific content. + + This is an abstract base class. There are three concrete + subclasses: + + - LeafPattern matches a single leaf node; + - NodePattern matches a single node (usually non-leaf); + - WildcardPattern matches a sequence of nodes of variable length. + """ + + # Defaults for instance variables + type: int | None + type = None # Node type (token if < 256, symbol if >= 256) + content: Any = None # Optional content matching pattern + name: str | None = None # Optional name used to store match in results dict + + def __new__(cls, *args, **kwds): + """Constructor that prevents BasePattern from being instantiated.""" + assert cls is not BasePattern, "Cannot instantiate BasePattern" + return object.__new__(cls) + + def __repr__(self) -> str: + assert self.type is not None + args = [type_repr(self.type), self.content, self.name] + while args and args[-1] is None: + del args[-1] + return f"{self.__class__.__name__}({', '.join(map(repr, args))})" + + def _submatch(self, node, results=None) -> bool: + raise NotImplementedError + + def optimize(self) -> "BasePattern": + """ + A subclass can define this as a hook for optimizations. + + Returns either self or another node with the same effect. + """ + return self + + def match(self, node: NL, results: _Results | None = None) -> bool: + """ + Does this pattern exactly match a node? + + Returns True if it matches, False if not. + + If results is not None, it must be a dict which will be + updated with the nodes matching named subpatterns. + + Default implementation for non-wildcard patterns. + """ + if self.type is not None and node.type != self.type: + return False + if self.content is not None: + r: _Results | None = None + if results is not None: + r = {} + if not self._submatch(node, r): + return False + if r: + assert results is not None + results.update(r) + if results is not None and self.name: + results[self.name] = node + return True + + def match_seq(self, nodes: list[NL], results: _Results | None = None) -> bool: + """ + Does this pattern exactly match a sequence of nodes? + + Default implementation for non-wildcard patterns. + """ + if len(nodes) != 1: + return False + return self.match(nodes[0], results) + + def generate_matches(self, nodes: list[NL]) -> Iterator[tuple[int, _Results]]: + """ + Generator yielding all matches for this pattern. + + Default implementation for non-wildcard patterns. + """ + r: _Results = {} + if nodes and self.match(nodes[0], r): + yield 1, r + + +class LeafPattern(BasePattern): + def __init__( + self, + type: int | None = None, + content: str | None = None, + name: str | None = None, + ) -> None: + """ + Initializer. Takes optional type, content, and name. + + The type, if given must be a token type (< 256). If not given, + this matches any *leaf* node; the content may still be required. + + The content, if given, must be a string. + + If a name is given, the matching node is stored in the results + dict under that key. + """ + if type is not None: + assert 0 <= type < 256, type + if content is not None: + assert isinstance(content, str), repr(content) + self.type = type + self.content = content + self.name = name + + def match(self, node: NL, results=None) -> bool: + """Override match() to insist on a leaf node.""" + if not isinstance(node, Leaf): + return False + return BasePattern.match(self, node, results) + + def _submatch(self, node, results=None): + """ + Match the pattern's content to the node's children. + + This assumes the node type matches and self.content is not None. + + Returns True if it matches, False if not. + + If results is not None, it must be a dict which will be + updated with the nodes matching named subpatterns. + + When returning False, the results dict may still be updated. + """ + return self.content == node.value + + +class NodePattern(BasePattern): + wildcards: bool = False + + def __init__( + self, + type: int | None = None, + content: Iterable[str] | None = None, + name: str | None = None, + ) -> None: + """ + Initializer. Takes optional type, content, and name. + + The type, if given, must be a symbol type (>= 256). If the + type is None this matches *any* single node (leaf or not), + except if content is not None, in which it only matches + non-leaf nodes that also match the content pattern. + + The content, if not None, must be a sequence of Patterns that + must match the node's children exactly. If the content is + given, the type must not be None. + + If a name is given, the matching node is stored in the results + dict under that key. + """ + if type is not None: + assert type >= 256, type + if content is not None: + assert not isinstance(content, str), repr(content) + newcontent = list(content) + for i, item in enumerate(newcontent): + assert isinstance(item, BasePattern), (i, item) + # I don't even think this code is used anywhere, but it does cause + # unreachable errors from mypy. This function's signature does look + # odd though *shrug*. + if isinstance(item, WildcardPattern): # type: ignore[unreachable] + self.wildcards = True # type: ignore[unreachable] + self.type = type + self.content = newcontent # TODO: this is unbound when content is None + self.name = name + + def _submatch(self, node, results=None) -> bool: + """ + Match the pattern's content to the node's children. + + This assumes the node type matches and self.content is not None. + + Returns True if it matches, False if not. + + If results is not None, it must be a dict which will be + updated with the nodes matching named subpatterns. + + When returning False, the results dict may still be updated. + """ + if self.wildcards: + for c, r in generate_matches(self.content, node.children): + if c == len(node.children): + if results is not None: + results.update(r) + return True + return False + if len(self.content) != len(node.children): + return False + for subpattern, child in zip(self.content, node.children): + if not subpattern.match(child, results): + return False + return True + + +class WildcardPattern(BasePattern): + """ + A wildcard pattern can match zero or more nodes. + + This has all the flexibility needed to implement patterns like: + + .* .+ .? .{m,n} + (a b c | d e | f) + (...)* (...)+ (...)? (...){m,n} + + except it always uses non-greedy matching. + """ + + min: int + max: int + + def __init__( + self, + content: str | None = None, + min: int = 0, + max: int = HUGE, + name: str | None = None, + ) -> None: + """ + Initializer. + + Args: + content: optional sequence of subsequences of patterns; + if absent, matches one node; + if present, each subsequence is an alternative [*] + min: optional minimum number of times to match, default 0 + max: optional maximum number of times to match, default HUGE + name: optional name assigned to this match + + [*] Thus, if content is [[a, b, c], [d, e], [f, g, h]] this is + equivalent to (a b c | d e | f g h); if content is None, + this is equivalent to '.' in regular expression terms. + The min and max parameters work as follows: + min=0, max=maxint: .* + min=1, max=maxint: .+ + min=0, max=1: .? + min=1, max=1: . + If content is not None, replace the dot with the parenthesized + list of alternatives, e.g. (a b c | d e | f g h)* + """ + assert 0 <= min <= max <= HUGE, (min, max) + if content is not None: + f = lambda s: tuple(s) + wrapped_content = tuple(map(f, content)) # Protect against alterations + # Check sanity of alternatives + assert len(wrapped_content), repr( + wrapped_content + ) # Can't have zero alternatives + for alt in wrapped_content: + assert len(alt), repr(alt) # Can have empty alternatives + self.content = wrapped_content + self.min = min + self.max = max + self.name = name + + def optimize(self) -> Any: + """Optimize certain stacked wildcard patterns.""" + subpattern = None + if ( + self.content is not None + and len(self.content) == 1 + and len(self.content[0]) == 1 + ): + subpattern = self.content[0][0] + if self.min == 1 and self.max == 1: + if self.content is None: + return NodePattern(name=self.name) + if subpattern is not None and self.name == subpattern.name: + return subpattern.optimize() + if ( + self.min <= 1 + and isinstance(subpattern, WildcardPattern) + and subpattern.min <= 1 + and self.name == subpattern.name + ): + return WildcardPattern( + subpattern.content, + self.min * subpattern.min, + self.max * subpattern.max, + subpattern.name, + ) + return self + + def match(self, node, results=None) -> bool: + """Does this pattern exactly match a node?""" + return self.match_seq([node], results) + + def match_seq(self, nodes, results=None) -> bool: + """Does this pattern exactly match a sequence of nodes?""" + for c, r in self.generate_matches(nodes): + if c == len(nodes): + if results is not None: + results.update(r) + if self.name: + results[self.name] = list(nodes) + return True + return False + + def generate_matches(self, nodes) -> Iterator[tuple[int, _Results]]: + """ + Generator yielding matches for a sequence of nodes. + + Args: + nodes: sequence of nodes + + Yields: + (count, results) tuples where: + count: the match comprises nodes[:count]; + results: dict containing named submatches. + """ + if self.content is None: + # Shortcut for special case (see __init__.__doc__) + for count in range(self.min, 1 + min(len(nodes), self.max)): + r = {} + if self.name: + r[self.name] = nodes[:count] + yield count, r + elif self.name == "bare_name": + yield self._bare_name_matches(nodes) + else: + # The reason for this is that hitting the recursion limit usually + # results in some ugly messages about how RuntimeErrors are being + # ignored. We only have to do this on CPython, though, because other + # implementations don't have this nasty bug in the first place. + if hasattr(sys, "getrefcount"): + save_stderr = sys.stderr + sys.stderr = StringIO() + try: + for count, r in self._recursive_matches(nodes, 0): + if self.name: + r[self.name] = nodes[:count] + yield count, r + except RuntimeError: + # We fall back to the iterative pattern matching scheme if the recursive + # scheme hits the recursion limit. + for count, r in self._iterative_matches(nodes): + if self.name: + r[self.name] = nodes[:count] + yield count, r + finally: + if hasattr(sys, "getrefcount"): + sys.stderr = save_stderr + + def _iterative_matches(self, nodes) -> Iterator[tuple[int, _Results]]: + """Helper to iteratively yield the matches.""" + nodelen = len(nodes) + if 0 >= self.min: + yield 0, {} + + results = [] + # generate matches that use just one alt from self.content + for alt in self.content: + for c, r in generate_matches(alt, nodes): + yield c, r + results.append((c, r)) + + # for each match, iterate down the nodes + while results: + new_results = [] + for c0, r0 in results: + # stop if the entire set of nodes has been matched + if c0 < nodelen and c0 <= self.max: + for alt in self.content: + for c1, r1 in generate_matches(alt, nodes[c0:]): + if c1 > 0: + r = {} + r.update(r0) + r.update(r1) + yield c0 + c1, r + new_results.append((c0 + c1, r)) + results = new_results + + def _bare_name_matches(self, nodes) -> tuple[int, _Results]: + """Special optimized matcher for bare_name.""" + count = 0 + r = {} # type: _Results + done = False + max = len(nodes) + while not done and count < max: + done = True + for leaf in self.content: + if leaf[0].match(nodes[count], r): + count += 1 + done = False + break + assert self.name is not None + r[self.name] = nodes[:count] + return count, r + + def _recursive_matches(self, nodes, count) -> Iterator[tuple[int, _Results]]: + """Helper to recursively yield the matches.""" + assert self.content is not None + if count >= self.min: + yield 0, {} + if count < self.max: + for alt in self.content: + for c0, r0 in generate_matches(alt, nodes): + for c1, r1 in self._recursive_matches(nodes[c0:], count + 1): + r = {} + r.update(r0) + r.update(r1) + yield c0 + c1, r + + +class NegatedPattern(BasePattern): + def __init__(self, content: BasePattern | None = None) -> None: + """ + Initializer. + + The argument is either a pattern or None. If it is None, this + only matches an empty sequence (effectively '$' in regex + lingo). If it is not None, this matches whenever the argument + pattern doesn't have any matches. + """ + if content is not None: + assert isinstance(content, BasePattern), repr(content) + self.content = content + + def match(self, node, results=None) -> bool: + # We never match a node in its entirety + return False + + def match_seq(self, nodes, results=None) -> bool: + # We only match an empty sequence of nodes in its entirety + return len(nodes) == 0 + + def generate_matches(self, nodes: list[NL]) -> Iterator[tuple[int, _Results]]: + if self.content is None: + # Return a match if there is an empty sequence + if len(nodes) == 0: + yield 0, {} + else: + # Return a match if the argument pattern has no matches + for c, r in self.content.generate_matches(nodes): + return + yield 0, {} + + +def generate_matches( + patterns: list[BasePattern], nodes: list[NL] +) -> Iterator[tuple[int, _Results]]: + """ + Generator yielding matches for a sequence of patterns and nodes. + + Args: + patterns: a sequence of patterns + nodes: a sequence of nodes + + Yields: + (count, results) tuples where: + count: the entire sequence of patterns matches nodes[:count]; + results: dict containing named submatches. + """ + if not patterns: + yield 0, {} + else: + p, rest = patterns[0], patterns[1:] + for c0, r0 in p.generate_matches(nodes): + if not rest: + yield c0, r0 + else: + for c1, r1 in generate_matches(rest, nodes[c0:]): + r = {} + r.update(r0) + r.update(r1) + yield c0 + c1, r diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..1a0dd74 --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,28 @@ +import pytest + +pytest_plugins = ["tests.optional"] + +PRINT_FULL_TREE: bool = False +PRINT_TREE_DIFF: bool = True + + +def pytest_addoption(parser: pytest.Parser) -> None: + parser.addoption( + "--print-full-tree", + action="store_true", + default=False, + help="print full syntax trees on failed tests", + ) + parser.addoption( + "--print-tree-diff", + action="store_true", + default=True, + help="print diff of syntax trees on failed tests", + ) + + +def pytest_configure(config: pytest.Config) -> None: + global PRINT_FULL_TREE + global PRINT_TREE_DIFF + PRINT_FULL_TREE = config.getoption("--print-full-tree") + PRINT_TREE_DIFF = config.getoption("--print-tree-diff") diff --git a/tests/data/cases/allow_empty_first_line.py b/tests/data/cases/allow_empty_first_line.py new file mode 100644 index 0000000..32a170a --- /dev/null +++ b/tests/data/cases/allow_empty_first_line.py @@ -0,0 +1,166 @@ +def foo(): + """ + Docstring + """ + + # Here we go + if x: + + # This is also now fine + a = 123 + + else: + # But not necessary + a = 123 + + if y: + + while True: + + """ + Long comment here + """ + a = 123 + + if z: + + for _ in range(100): + a = 123 + else: + + try: + + # this should be ok + a = 123 + except: + + """also this""" + a = 123 + + +def bar(): + + if x: + a = 123 + + +def baz(): + + # OK + if x: + a = 123 + +def quux(): + + new_line = here + + +class Cls: + + def method(self): + + pass + + +async def async_fn(): + + """Docstring.""" + + +@decorated +async def async_fn(): + + """Docstring.""" + + +def top_level( + a: int, + b: str, +) -> Whatever[Generic, Something]: + + def nested(x: int) -> int: + pass + +# output + +def foo(): + """ + Docstring + """ + + # Here we go + if x: + + # This is also now fine + a = 123 + + else: + # But not necessary + a = 123 + + if y: + + while True: + + """ + Long comment here + """ + a = 123 + + if z: + + for _ in range(100): + a = 123 + else: + + try: + + # this should be ok + a = 123 + except: + + """also this""" + a = 123 + + +def bar(): + + if x: + a = 123 + + +def baz(): + + # OK + if x: + a = 123 + + +def quux(): + + new_line = here + + +class Cls: + + def method(self): + + pass + + +async def async_fn(): + """Docstring.""" + + +@decorated +async def async_fn(): + """Docstring.""" + + +def top_level( + a: int, + b: str, +) -> Whatever[Generic, Something]: + + def nested(x: int) -> int: + pass diff --git a/tests/data/cases/annotations.py b/tests/data/cases/annotations.py new file mode 100644 index 0000000..4d7af3d --- /dev/null +++ b/tests/data/cases/annotations.py @@ -0,0 +1,17 @@ +# regression test for #1765 +class Foo: + def foo(self): + if True: + content_ids: Mapping[ + str, Optional[ContentId] + ] = self.publisher_content_store.store_config_contents(files) + +# output + +# regression test for #1765 +class Foo: + def foo(self): + if True: + content_ids: Mapping[str, Optional[ContentId]] = ( + self.publisher_content_store.store_config_contents(files) + ) \ No newline at end of file diff --git a/tests/data/cases/async_stmts.py b/tests/data/cases/async_stmts.py new file mode 100644 index 0000000..fe9594b --- /dev/null +++ b/tests/data/cases/async_stmts.py @@ -0,0 +1,27 @@ +async def func() -> (int): + return 0 + + +@decorated +async def func() -> (int): + return 0 + + +async for (item) in async_iter: + pass + + +# output + + +async def func() -> int: + return 0 + + +@decorated +async def func() -> int: + return 0 + + +async for item in async_iter: + pass diff --git a/tests/data/cases/attribute_access_on_number_literals.py b/tests/data/cases/attribute_access_on_number_literals.py new file mode 100644 index 0000000..7c16bdf --- /dev/null +++ b/tests/data/cases/attribute_access_on_number_literals.py @@ -0,0 +1,47 @@ +x = 123456789 .bit_count() +x = (123456).__abs__() +x = .1.is_integer() +x = 1. .imag +x = 1E+1.imag +x = 1E-1.real +x = 123456789.123456789.hex() +x = 123456789.123456789E123456789 .real +x = 123456789E123456789 .conjugate() +x = 123456789J.real +x = 123456789.123456789J.__add__(0b1011.bit_length()) +x = 0XB1ACC.conjugate() +x = 0B1011 .conjugate() +x = 0O777 .real +x = 0.000000006 .hex() +x = -100.0000J + +if 10 .real: + ... + +y = 100[no] +y = 100(no) + +# output + +x = (123456789).bit_count() +x = (123456).__abs__() +x = (0.1).is_integer() +x = (1.0).imag +x = (1e1).imag +x = (1e-1).real +x = (123456789.123456789).hex() +x = (123456789.123456789e123456789).real +x = (123456789e123456789).conjugate() +x = 123456789j.real +x = 123456789.123456789j.__add__(0b1011.bit_length()) +x = 0xB1ACC.conjugate() +x = 0b1011.conjugate() +x = 0o777.real +x = (0.000000006).hex() +x = -100.0000j + +if (10).real: + ... + +y = 100[no] +y = 100(no) diff --git a/tests/data/cases/backslash_before_indent.py b/tests/data/cases/backslash_before_indent.py new file mode 100644 index 0000000..2d126a9 --- /dev/null +++ b/tests/data/cases/backslash_before_indent.py @@ -0,0 +1,24 @@ +# flags: --minimum-version=3.10 +class Plotter: +\ + pass + +class AnotherCase: + \ + """Some + \ + Docstring + """ + +# output + +class Plotter: + + pass + + +class AnotherCase: + """Some + \ + Docstring + """ diff --git a/tests/data/cases/beginning_backslash.py b/tests/data/cases/beginning_backslash.py new file mode 100644 index 0000000..66c347d --- /dev/null +++ b/tests/data/cases/beginning_backslash.py @@ -0,0 +1,12 @@ +\ + + + + + +print("hello, world") + +# output + + +print("hello, world") diff --git a/tests/data/cases/bracketmatch.py b/tests/data/cases/bracketmatch.py new file mode 100644 index 0000000..0aaa2d8 --- /dev/null +++ b/tests/data/cases/bracketmatch.py @@ -0,0 +1,15 @@ +for ((x in {}) or {})['a'] in x: + pass +pem_spam = lambda l, spam = { + "x": 3 +}: not spam.get(l.strip()) +lambda x=lambda y={1: 3}: y['x':lambda y: {1: 2}]: x + + +# output + + +for ((x in {}) or {})["a"] in x: + pass +pem_spam = lambda l, spam={"x": 3}: not spam.get(l.strip()) +lambda x=lambda y={1: 3}: y["x" : lambda y: {1: 2}]: x diff --git a/tests/data/cases/bytes_docstring.py b/tests/data/cases/bytes_docstring.py new file mode 100644 index 0000000..2326e95 --- /dev/null +++ b/tests/data/cases/bytes_docstring.py @@ -0,0 +1,34 @@ +def bitey(): + b" not a docstring" + +def bitey2(): + b' also not a docstring' + +def triple_quoted_bytes(): + b""" not a docstring""" + +def triple_quoted_bytes2(): + b''' also not a docstring''' + +def capitalized_bytes(): + B" NOT A DOCSTRING" + +# output +def bitey(): + b" not a docstring" + + +def bitey2(): + b" also not a docstring" + + +def triple_quoted_bytes(): + b""" not a docstring""" + + +def triple_quoted_bytes2(): + b""" also not a docstring""" + + +def capitalized_bytes(): + b" NOT A DOCSTRING" \ No newline at end of file diff --git a/tests/data/cases/cantfit.py b/tests/data/cases/cantfit.py new file mode 100644 index 0000000..6191192 --- /dev/null +++ b/tests/data/cases/cantfit.py @@ -0,0 +1,100 @@ +# long variable name +this_is_a_ridiculously_long_name_and_nobody_in_their_right_mind_would_use_one_like_it = 0 +this_is_a_ridiculously_long_name_and_nobody_in_their_right_mind_would_use_one_like_it = 1 # with a comment +this_is_a_ridiculously_long_name_and_nobody_in_their_right_mind_would_use_one_like_it = [ + 1, 2, 3 +] +this_is_a_ridiculously_long_name_and_nobody_in_their_right_mind_would_use_one_like_it = function() +this_is_a_ridiculously_long_name_and_nobody_in_their_right_mind_would_use_one_like_it = function( + arg1, arg2, arg3 +) +this_is_a_ridiculously_long_name_and_nobody_in_their_right_mind_would_use_one_like_it = function( + [1, 2, 3], arg1, [1, 2, 3], arg2, [1, 2, 3], arg3 +) +# long function name +normal_name = but_the_function_name_is_now_ridiculously_long_and_it_is_still_super_annoying() +normal_name = but_the_function_name_is_now_ridiculously_long_and_it_is_still_super_annoying( + arg1, arg2, arg3 +) +normal_name = but_the_function_name_is_now_ridiculously_long_and_it_is_still_super_annoying( + [1, 2, 3], arg1, [1, 2, 3], arg2, [1, 2, 3], arg3 +) +string_variable_name = ( + "a string that is waaaaaaaayyyyyyyy too long, even in parens, there's nothing you can do" # noqa +) +for key in """ + hostname + port + username +""".split(): + if key in self.connect_kwargs: + raise ValueError(err.format(key)) +concatenated_strings = "some strings that are " "concatenated implicitly, so if you put them on separate " "lines it will fit" +del concatenated_strings, string_variable_name, normal_function_name, normal_name, need_more_to_make_the_line_long_enough +del ([], name_1, name_2), [(), [], name_4, name_3], name_1[[name_2 for name_1 in name_0]] +del (), + +# output + + +# long variable name +this_is_a_ridiculously_long_name_and_nobody_in_their_right_mind_would_use_one_like_it = ( + 0 +) +this_is_a_ridiculously_long_name_and_nobody_in_their_right_mind_would_use_one_like_it = ( + 1 # with a comment +) +this_is_a_ridiculously_long_name_and_nobody_in_their_right_mind_would_use_one_like_it = [ + 1, + 2, + 3, +] +this_is_a_ridiculously_long_name_and_nobody_in_their_right_mind_would_use_one_like_it = ( + function() +) +this_is_a_ridiculously_long_name_and_nobody_in_their_right_mind_would_use_one_like_it = function( + arg1, arg2, arg3 +) +this_is_a_ridiculously_long_name_and_nobody_in_their_right_mind_would_use_one_like_it = function( + [1, 2, 3], arg1, [1, 2, 3], arg2, [1, 2, 3], arg3 +) +# long function name +normal_name = ( + but_the_function_name_is_now_ridiculously_long_and_it_is_still_super_annoying() +) +normal_name = ( + but_the_function_name_is_now_ridiculously_long_and_it_is_still_super_annoying( + arg1, arg2, arg3 + ) +) +normal_name = ( + but_the_function_name_is_now_ridiculously_long_and_it_is_still_super_annoying( + [1, 2, 3], arg1, [1, 2, 3], arg2, [1, 2, 3], arg3 + ) +) +string_variable_name = "a string that is waaaaaaaayyyyyyyy too long, even in parens, there's nothing you can do" # noqa +for key in """ + hostname + port + username +""".split(): + if key in self.connect_kwargs: + raise ValueError(err.format(key)) +concatenated_strings = ( + "some strings that are " + "concatenated implicitly, so if you put them on separate " + "lines it will fit" +) +del ( + concatenated_strings, + string_variable_name, + normal_function_name, + normal_name, + need_more_to_make_the_line_long_enough, +) +del ( + ([], name_1, name_2), + [(), [], name_4, name_3], + name_1[[name_2 for name_1 in name_0]], +) +del ((),) diff --git a/tests/data/cases/class_blank_parentheses.py b/tests/data/cases/class_blank_parentheses.py new file mode 100644 index 0000000..3c460d9 --- /dev/null +++ b/tests/data/cases/class_blank_parentheses.py @@ -0,0 +1,59 @@ +class SimpleClassWithBlankParentheses(): + pass +class ClassWithSpaceParentheses ( ): + first_test_data = 90 + second_test_data = 100 + def test_func(self): + return None +class ClassWithEmptyFunc(object): + + def func_with_blank_parentheses(): + return 5 + + +def public_func_with_blank_parentheses(): + return None +def class_under_the_func_with_blank_parentheses(): + class InsideFunc(): + pass +class NormalClass ( +): + def func_for_testing(self, first, second): + sum = first + second + return sum + + +# output + + +class SimpleClassWithBlankParentheses: + pass + + +class ClassWithSpaceParentheses: + first_test_data = 90 + second_test_data = 100 + + def test_func(self): + return None + + +class ClassWithEmptyFunc(object): + + def func_with_blank_parentheses(): + return 5 + + +def public_func_with_blank_parentheses(): + return None + + +def class_under_the_func_with_blank_parentheses(): + class InsideFunc: + pass + + +class NormalClass: + def func_for_testing(self, first, second): + sum = first + second + return sum diff --git a/tests/data/cases/class_methods_new_line.py b/tests/data/cases/class_methods_new_line.py new file mode 100644 index 0000000..9a96ffe --- /dev/null +++ b/tests/data/cases/class_methods_new_line.py @@ -0,0 +1,270 @@ +class ClassSimplest: + pass +class ClassWithSingleField: + a = 1 +class ClassWithJustTheDocstring: + """Just a docstring.""" +class ClassWithInit: + def __init__(self): + pass +class ClassWithTheDocstringAndInit: + """Just a docstring.""" + def __init__(self): + pass +class ClassWithInitAndVars: + cls_var = 100 + def __init__(self): + pass +class ClassWithInitAndVarsAndDocstring: + """Test class""" + cls_var = 100 + def __init__(self): + pass +class ClassWithDecoInit: + @deco + def __init__(self): + pass +class ClassWithDecoInitAndVars: + cls_var = 100 + @deco + def __init__(self): + pass +class ClassWithDecoInitAndVarsAndDocstring: + """Test class""" + cls_var = 100 + @deco + def __init__(self): + pass +class ClassSimplestWithInner: + class Inner: + pass +class ClassSimplestWithInnerWithDocstring: + class Inner: + """Just a docstring.""" + def __init__(self): + pass +class ClassWithSingleFieldWithInner: + a = 1 + class Inner: + pass +class ClassWithJustTheDocstringWithInner: + """Just a docstring.""" + class Inner: + pass +class ClassWithInitWithInner: + class Inner: + pass + def __init__(self): + pass +class ClassWithInitAndVarsWithInner: + cls_var = 100 + class Inner: + pass + def __init__(self): + pass +class ClassWithInitAndVarsAndDocstringWithInner: + """Test class""" + cls_var = 100 + class Inner: + pass + def __init__(self): + pass +class ClassWithDecoInitWithInner: + class Inner: + pass + @deco + def __init__(self): + pass +class ClassWithDecoInitAndVarsWithInner: + cls_var = 100 + class Inner: + pass + @deco + def __init__(self): + pass +class ClassWithDecoInitAndVarsAndDocstringWithInner: + """Test class""" + cls_var = 100 + class Inner: + pass + @deco + def __init__(self): + pass +class ClassWithDecoInitAndVarsAndDocstringWithInner2: + """Test class""" + class Inner: + pass + cls_var = 100 + @deco + def __init__(self): + pass + + +# output + + +class ClassSimplest: + pass + + +class ClassWithSingleField: + a = 1 + + +class ClassWithJustTheDocstring: + """Just a docstring.""" + + +class ClassWithInit: + def __init__(self): + pass + + +class ClassWithTheDocstringAndInit: + """Just a docstring.""" + + def __init__(self): + pass + + +class ClassWithInitAndVars: + cls_var = 100 + + def __init__(self): + pass + + +class ClassWithInitAndVarsAndDocstring: + """Test class""" + + cls_var = 100 + + def __init__(self): + pass + + +class ClassWithDecoInit: + @deco + def __init__(self): + pass + + +class ClassWithDecoInitAndVars: + cls_var = 100 + + @deco + def __init__(self): + pass + + +class ClassWithDecoInitAndVarsAndDocstring: + """Test class""" + + cls_var = 100 + + @deco + def __init__(self): + pass + + +class ClassSimplestWithInner: + class Inner: + pass + + +class ClassSimplestWithInnerWithDocstring: + class Inner: + """Just a docstring.""" + + def __init__(self): + pass + + +class ClassWithSingleFieldWithInner: + a = 1 + + class Inner: + pass + + +class ClassWithJustTheDocstringWithInner: + """Just a docstring.""" + + class Inner: + pass + + +class ClassWithInitWithInner: + class Inner: + pass + + def __init__(self): + pass + + +class ClassWithInitAndVarsWithInner: + cls_var = 100 + + class Inner: + pass + + def __init__(self): + pass + + +class ClassWithInitAndVarsAndDocstringWithInner: + """Test class""" + + cls_var = 100 + + class Inner: + pass + + def __init__(self): + pass + + +class ClassWithDecoInitWithInner: + class Inner: + pass + + @deco + def __init__(self): + pass + + +class ClassWithDecoInitAndVarsWithInner: + cls_var = 100 + + class Inner: + pass + + @deco + def __init__(self): + pass + + +class ClassWithDecoInitAndVarsAndDocstringWithInner: + """Test class""" + + cls_var = 100 + + class Inner: + pass + + @deco + def __init__(self): + pass + + +class ClassWithDecoInitAndVarsAndDocstringWithInner2: + """Test class""" + + class Inner: + pass + + cls_var = 100 + + @deco + def __init__(self): + pass diff --git a/tests/data/cases/collections.py b/tests/data/cases/collections.py new file mode 100644 index 0000000..6843166 --- /dev/null +++ b/tests/data/cases/collections.py @@ -0,0 +1,174 @@ +import core, time, a + +from . import A, B, C + +# keeps existing trailing comma +from foo import ( + bar, +) + +# also keeps existing structure +from foo import ( + baz, + qux, +) + +# `as` works as well +from foo import ( + xyzzy as magic, +) + +a = {1,2,3,} +b = { +1,2, + 3} +c = { + 1, + 2, + 3, +} +x = 1, +y = narf(), +nested = {(1,2,3),(4,5,6),} +nested_no_trailing_comma = {(1,2,3),(4,5,6)} +nested_long_lines = ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "cccccccccccccccccccccccccccccccccccccccc", (1, 2, 3), "dddddddddddddddddddddddddddddddddddddddd"] +{"oneple": (1,),} +{"oneple": (1,)} +['ls', 'lsoneple/%s' % (foo,)] +x = {"oneple": (1,)} +y = {"oneple": (1,),} +assert False, ("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa wraps %s" % bar) + +# looping over a 1-tuple should also not get wrapped +for x in (1,): + pass +for (x,) in (1,), (2,), (3,): + pass + +[1, 2, 3,] + +division_result_tuple = (6/2,) +print("foo %r", (foo.bar,)) + +if True: + IGNORED_TYPES_FOR_ATTRIBUTE_CHECKING = ( + Config.IGNORED_TYPES_FOR_ATTRIBUTE_CHECKING + | {pylons.controllers.WSGIController} + ) + +if True: + ec2client.get_waiter('instance_stopped').wait( + InstanceIds=[instance.id], + WaiterConfig={ + 'Delay': 5, + }) + ec2client.get_waiter("instance_stopped").wait( + InstanceIds=[instance.id], + WaiterConfig={"Delay": 5,}, + ) + ec2client.get_waiter("instance_stopped").wait( + InstanceIds=[instance.id], WaiterConfig={"Delay": 5,}, + ) + +# output + + +import core, time, a + +from . import A, B, C + +# keeps existing trailing comma +from foo import ( + bar, +) + +# also keeps existing structure +from foo import ( + baz, + qux, +) + +# `as` works as well +from foo import ( + xyzzy as magic, +) + +a = { + 1, + 2, + 3, +} +b = {1, 2, 3} +c = { + 1, + 2, + 3, +} +x = (1,) +y = (narf(),) +nested = { + (1, 2, 3), + (4, 5, 6), +} +nested_no_trailing_comma = {(1, 2, 3), (4, 5, 6)} +nested_long_lines = [ + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "cccccccccccccccccccccccccccccccccccccccc", + (1, 2, 3), + "dddddddddddddddddddddddddddddddddddddddd", +] +{ + "oneple": (1,), +} +{"oneple": (1,)} +["ls", "lsoneple/%s" % (foo,)] +x = {"oneple": (1,)} +y = { + "oneple": (1,), +} +assert False, ( + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa wraps %s" + % bar +) + +# looping over a 1-tuple should also not get wrapped +for x in (1,): + pass +for (x,) in (1,), (2,), (3,): + pass + +[ + 1, + 2, + 3, +] + +division_result_tuple = (6 / 2,) +print("foo %r", (foo.bar,)) + +if True: + IGNORED_TYPES_FOR_ATTRIBUTE_CHECKING = ( + Config.IGNORED_TYPES_FOR_ATTRIBUTE_CHECKING + | {pylons.controllers.WSGIController} + ) + +if True: + ec2client.get_waiter("instance_stopped").wait( + InstanceIds=[instance.id], + WaiterConfig={ + "Delay": 5, + }, + ) + ec2client.get_waiter("instance_stopped").wait( + InstanceIds=[instance.id], + WaiterConfig={ + "Delay": 5, + }, + ) + ec2client.get_waiter("instance_stopped").wait( + InstanceIds=[instance.id], + WaiterConfig={ + "Delay": 5, + }, + ) diff --git a/tests/data/cases/comment_after_escaped_newline.py b/tests/data/cases/comment_after_escaped_newline.py new file mode 100644 index 0000000..133c230 --- /dev/null +++ b/tests/data/cases/comment_after_escaped_newline.py @@ -0,0 +1,20 @@ +def bob(): \ + # pylint: disable=W9016 + pass + + +def bobtwo(): \ + \ + # some comment here + pass + +# output + +def bob(): # pylint: disable=W9016 + pass + + +def bobtwo(): + + # some comment here + pass diff --git a/tests/data/cases/comment_in_subscript_annotation.py b/tests/data/cases/comment_in_subscript_annotation.py new file mode 100644 index 0000000..e3c0a7d --- /dev/null +++ b/tests/data/cases/comment_in_subscript_annotation.py @@ -0,0 +1,25 @@ +# Regression test for https://github.com/psf/black/issues/4733. +aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: list[ # bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb + int +] = [] + + +# Original (non-minimized) snippet from the issue report. +def foo(): + possibly_redundant_lowlevel_checkpoints: list[ # pyright: ignore[reportUnknownVariableType] + cst.BaseExpression + ] = field( default_factory=list) + +# output + +# Regression test for https://github.com/psf/black/issues/4733. +aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: list[ # bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb + int +] = [] + + +# Original (non-minimized) snippet from the issue report. +def foo(): + possibly_redundant_lowlevel_checkpoints: list[ # pyright: ignore[reportUnknownVariableType] + cst.BaseExpression + ] = field(default_factory=list) diff --git a/tests/data/cases/comment_type_hint.py b/tests/data/cases/comment_type_hint.py new file mode 100644 index 0000000..2992da8 --- /dev/null +++ b/tests/data/cases/comment_type_hint.py @@ -0,0 +1,3 @@ +# flags: --no-preview-line-length-1 +# split out from comments2 as it does not work with line-length=1, losing the comment +a = "type comment with trailing space" # type: str diff --git a/tests/data/cases/comments.py b/tests/data/cases/comments.py new file mode 100644 index 0000000..c34daaf --- /dev/null +++ b/tests/data/cases/comments.py @@ -0,0 +1,96 @@ +#!/usr/bin/env python3 +# fmt: on +# Some license here. +# +# Has many lines. Many, many lines. +# Many, many, many lines. +"""Module docstring. + +Possibly also many, many lines. +""" + +import os.path +import sys + +import a +from b.c import X # some noqa comment + +try: + import fast +except ImportError: + import slow as fast + + +# Some comment before a function. +y = 1 +( + # some strings + y # type: ignore +) + + +def function(default=None): + """Docstring comes first. + + Possibly many lines. + """ + # FIXME: Some comment about why this function is crap but still in production. + import inner_imports + + if inner_imports.are_evil(): + # Explains why we have this if. + # In great detail indeed. + x = X() + return x.method1() # type: ignore + + # This return is also commented for some reason. + return default + + +# Explains why we use global state. +GLOBAL_STATE = {"a": a(1), "b": a(2), "c": a(3)} + + +# Another comment! +# This time two lines. + + +class Foo: + """Docstring for class Foo. Example from Sphinx docs.""" + + #: Doc comment for class attribute Foo.bar. + #: It can have multiple lines. + bar = 1 + + flox = 1.5 #: Doc comment for Foo.flox. One line only. + + baz = 2 + """Docstring for class attribute Foo.baz.""" + + def __init__(self): + #: Doc comment for instance attribute qux. + self.qux = 3 + + self.spam = 4 + """Docstring for instance attribute spam.""" + + +#'

This is pweave!

+ + +@fast(really=True) +async def wat(): + # This comment, for some reason \ + # contains a trailing backslash. + async with X.open_async() as x: # Some more comments + result = await x.method1() + # Comment after ending a block. + if result: + print("A OK", file=sys.stdout) + # Comment between things. + print() + + +# Some closing comments. +# Maybe Vim or Emacs directives for formatting. +# Who knows. diff --git a/tests/data/cases/comments2.py b/tests/data/cases/comments2.py new file mode 100644 index 0000000..261c5e9 --- /dev/null +++ b/tests/data/cases/comments2.py @@ -0,0 +1,344 @@ +from com.my_lovely_company.my_lovely_team.my_lovely_project.my_lovely_component import ( + MyLovelyCompanyTeamProjectComponent # NOT DRY +) +from com.my_lovely_company.my_lovely_team.my_lovely_project.my_lovely_component import ( + MyLovelyCompanyTeamProjectComponent as component # DRY +) + +# Please keep __all__ alphabetized within each category. + +__all__ = [ + # Super-special typing primitives. + 'Any', + 'Callable', + 'ClassVar', + + # ABCs (from collections.abc). + 'AbstractSet', # collections.abc.Set. + 'ByteString', + 'Container', + + # Concrete collection types. + 'Counter', + 'Deque', + 'Dict', + 'DefaultDict', + 'List', + 'Set', + 'FrozenSet', + 'NamedTuple', # Not really a type. + 'Generator', +] + +not_shareables = [ + # singletons + True, + False, + NotImplemented, ..., + # builtin types and objects + type, + object, + object(), + Exception(), + 42, + 100.0, + "spam", + # user-defined types and objects + Cheese, + Cheese("Wensleydale"), + SubBytes(b"spam"), +] + +if 'PYTHON' in os.environ: + add_compiler(compiler_from_env()) +else: + # for compiler in compilers.values(): + # add_compiler(compiler) + add_compiler(compilers[(7.0, 32)]) + # add_compiler(compilers[(7.1, 64)]) + +# Comment before function. +def inline_comments_in_brackets_ruin_everything(): + if typedargslist: + parameters.children = [ + children[0], # (1 + body, + children[-1] # )1 + ] + parameters.children = [ + children[0], + body, + children[-1], # type: ignore + ] + else: + parameters.children = [ + parameters.children[0], # (2 what if this was actually long + body, + parameters.children[-1], # )2 + ] + parameters.children = [parameters.what_if_this_was_actually_long.children[0], body, parameters.children[-1]] # type: ignore + if (self._proc is not None + # has the child process finished? + and self._returncode is None + # the child process has finished, but the + # transport hasn't been notified yet? + and self._proc.poll() is None): + pass + # no newline before or after + short = [ + # one + 1, + # two + 2] + + # no newline after + call(arg1, arg2, """ +short +""", arg3=True) + + ############################################################################ + + call2( + #short + arg1, + #but + arg2, + #multiline + """ +short +""", + # yup + arg3=True) + lcomp = [ + element # yup + for element in collection # yup + if element is not None # right + ] + lcomp2 = [ + # hello + element + # yup + for element in collection + # right + if element is not None + ] + lcomp3 = [ + # This one is actually too long to fit in a single line. + element.split('\n', 1)[0] + # yup + for element in collection.select_elements() + # right + if element is not None + ] + while True: + if False: + continue + + # and round and round we go + # and round and round we go + + # let's return + return Node( + syms.simple_stmt, + [ + Node(statement, result), + Leaf(token.NEWLINE, '\n') # FIXME: \r\n? + ], + ) + +CONFIG_FILES = [CONFIG_FILE, ] + SHARED_CONFIG_FILES + USER_CONFIG_FILES # type: Final + +class Test: + def _init_host(self, parsed) -> None: + if (parsed.hostname is None or # type: ignore + not parsed.hostname.strip()): + pass + + +####################### +### SECTION COMMENT ### +####################### + + +instruction()#comment with bad spacing + +# END COMMENTS +# MORE END COMMENTS + + +# output + + +from com.my_lovely_company.my_lovely_team.my_lovely_project.my_lovely_component import ( + MyLovelyCompanyTeamProjectComponent, # NOT DRY +) +from com.my_lovely_company.my_lovely_team.my_lovely_project.my_lovely_component import ( + MyLovelyCompanyTeamProjectComponent as component, # DRY +) + +# Please keep __all__ alphabetized within each category. + +__all__ = [ + # Super-special typing primitives. + "Any", + "Callable", + "ClassVar", + # ABCs (from collections.abc). + "AbstractSet", # collections.abc.Set. + "ByteString", + "Container", + # Concrete collection types. + "Counter", + "Deque", + "Dict", + "DefaultDict", + "List", + "Set", + "FrozenSet", + "NamedTuple", # Not really a type. + "Generator", +] + +not_shareables = [ + # singletons + True, + False, + NotImplemented, + ..., + # builtin types and objects + type, + object, + object(), + Exception(), + 42, + 100.0, + "spam", + # user-defined types and objects + Cheese, + Cheese("Wensleydale"), + SubBytes(b"spam"), +] + +if "PYTHON" in os.environ: + add_compiler(compiler_from_env()) +else: + # for compiler in compilers.values(): + # add_compiler(compiler) + add_compiler(compilers[(7.0, 32)]) + # add_compiler(compilers[(7.1, 64)]) + + +# Comment before function. +def inline_comments_in_brackets_ruin_everything(): + if typedargslist: + parameters.children = [children[0], body, children[-1]] # (1 # )1 + parameters.children = [ + children[0], + body, + children[-1], # type: ignore + ] + else: + parameters.children = [ + parameters.children[0], # (2 what if this was actually long + body, + parameters.children[-1], # )2 + ] + parameters.children = [parameters.what_if_this_was_actually_long.children[0], body, parameters.children[-1]] # type: ignore + if ( + self._proc is not None + # has the child process finished? + and self._returncode is None + # the child process has finished, but the + # transport hasn't been notified yet? + and self._proc.poll() is None + ): + pass + # no newline before or after + short = [ + # one + 1, + # two + 2, + ] + + # no newline after + call( + arg1, + arg2, + """ +short +""", + arg3=True, + ) + + ############################################################################ + + call2( + # short + arg1, + # but + arg2, + # multiline + """ +short +""", + # yup + arg3=True, + ) + lcomp = [ + element for element in collection if element is not None # yup # yup # right + ] + lcomp2 = [ + # hello + element + # yup + for element in collection + # right + if element is not None + ] + lcomp3 = [ + # This one is actually too long to fit in a single line. + element.split("\n", 1)[0] + # yup + for element in collection.select_elements() + # right + if element is not None + ] + while True: + if False: + continue + + # and round and round we go + # and round and round we go + + # let's return + return Node( + syms.simple_stmt, + [Node(statement, result), Leaf(token.NEWLINE, "\n")], # FIXME: \r\n? + ) + + +CONFIG_FILES = ( + [ + CONFIG_FILE, + ] + + SHARED_CONFIG_FILES + + USER_CONFIG_FILES +) # type: Final + + +class Test: + def _init_host(self, parsed) -> None: + if parsed.hostname is None or not parsed.hostname.strip(): # type: ignore + pass + + +####################### +### SECTION COMMENT ### +####################### + + +instruction() # comment with bad spacing + +# END COMMENTS +# MORE END COMMENTS diff --git a/tests/data/cases/comments3.py b/tests/data/cases/comments3.py new file mode 100644 index 0000000..f964bee --- /dev/null +++ b/tests/data/cases/comments3.py @@ -0,0 +1,48 @@ +# The percent-percent comments are Spyder IDE cells. + + +# %% +def func(): + x = """ + a really long string + """ + lcomp3 = [ + # This one is actually too long to fit in a single line. + element.split("\n", 1)[0] + # yup + for element in collection.select_elements() + # right + if element is not None + ] + # Capture each of the exceptions in the MultiError along with each of their causes and contexts + if isinstance(exc_value, MultiError): + embedded = [] + for exc in exc_value.exceptions: + if exc not in _seen: + embedded.append( + # This should be left alone (before) + traceback.TracebackException.from_exception( + exc, + limit=limit, + lookup_lines=lookup_lines, + capture_locals=capture_locals, + # copy the set of _seen exceptions so that duplicates + # shared between sub-exceptions are not omitted + _seen=set(_seen), + ) + # This should be left alone (after) + ) + + # everything is fine if the expression isn't nested + traceback.TracebackException.from_exception( + exc, + limit=limit, + lookup_lines=lookup_lines, + capture_locals=capture_locals, + # copy the set of _seen exceptions so that duplicates + # shared between sub-exceptions are not omitted + _seen=set(_seen), + ) + + +# %% \ No newline at end of file diff --git a/tests/data/cases/comments4.py b/tests/data/cases/comments4.py new file mode 100644 index 0000000..9f4f39d --- /dev/null +++ b/tests/data/cases/comments4.py @@ -0,0 +1,94 @@ +from com.my_lovely_company.my_lovely_team.my_lovely_project.my_lovely_component import ( + MyLovelyCompanyTeamProjectComponent, # NOT DRY +) +from com.my_lovely_company.my_lovely_team.my_lovely_project.my_lovely_component import ( + MyLovelyCompanyTeamProjectComponent as component, # DRY +) + + +class C: + @pytest.mark.parametrize( + ("post_data", "message"), + [ + # metadata_version errors. + ( + {}, + "None is an invalid value for Metadata-Version. Error: This field is" + " required. see" + " https://packaging.python.org/specifications/core-metadata", + ), + ( + {"metadata_version": "-1"}, + "'-1' is an invalid value for Metadata-Version. Error: Unknown Metadata" + " Version see" + " https://packaging.python.org/specifications/core-metadata", + ), + # name errors. + ( + {"metadata_version": "1.2"}, + "'' is an invalid value for Name. Error: This field is required. see" + " https://packaging.python.org/specifications/core-metadata", + ), + ( + {"metadata_version": "1.2", "name": "foo-"}, + "'foo-' is an invalid value for Name. Error: Must start and end with a" + " letter or numeral and contain only ascii numeric and '.', '_' and" + " '-'. see https://packaging.python.org/specifications/core-metadata", + ), + # version errors. + ( + {"metadata_version": "1.2", "name": "example"}, + "'' is an invalid value for Version. Error: This field is required. see" + " https://packaging.python.org/specifications/core-metadata", + ), + ( + {"metadata_version": "1.2", "name": "example", "version": "dog"}, + "'dog' is an invalid value for Version. Error: Must start and end with" + " a letter or numeral and contain only ascii numeric and '.', '_' and" + " '-'. see https://packaging.python.org/specifications/core-metadata", + ), + ], + ) + def test_fails_invalid_post_data( + self, pyramid_config, db_request, post_data, message + ): + pyramid_config.testing_securitypolicy(userid=1) + db_request.POST = MultiDict(post_data) + + +def foo(list_a, list_b): + results = ( + User.query.filter(User.foo == "bar") + .filter( # Because foo. + db.or_(User.field_a.astext.in_(list_a), User.field_b.astext.in_(list_b)) + ) + .filter(User.xyz.is_(None)) + # Another comment about the filtering on is_quux goes here. + .filter(db.not_(User.is_pending.astext.cast(db.Boolean).is_(True))) + .order_by(User.created_at.desc()) + .with_for_update(key_share=True) + .all() + ) + return results + + +def foo2(list_a, list_b): + # Standalone comment reasonably placed. + return ( + User.query.filter(User.foo == "bar") + .filter( + db.or_(User.field_a.astext.in_(list_a), User.field_b.astext.in_(list_b)) + ) + .filter(User.xyz.is_(None)) + ) + + +def foo3(list_a, list_b): + return ( + # Standalone comment but weirdly placed. + User.query.filter(User.foo == "bar") + .filter( + db.or_(User.field_a.astext.in_(list_a), User.field_b.astext.in_(list_b)) + ) + .filter(User.xyz.is_(None)) + ) diff --git a/tests/data/cases/comments5.py b/tests/data/cases/comments5.py new file mode 100644 index 0000000..f86e547 --- /dev/null +++ b/tests/data/cases/comments5.py @@ -0,0 +1,67 @@ +while True: + if something.changed: + do.stuff() # trailing comment + # Comment belongs to the `if` block. + # This one belongs to the `while` block. + + # Should this one, too? I guess so. + +# This one is properly standalone now. + +for i in range(100): + # first we do this + if i % 33 == 0: + break + + # then we do this + print(i) + # and finally we loop around + +with open(some_temp_file) as f: + data = f.read() + +try: + with open(some_other_file) as w: + w.write(data) + +except OSError: + print("problems") + +import sys + + +# leading function comment +def wat(): + ... + # trailing function comment + + +# SECTION COMMENT + + +# leading 1 +@deco1 +# leading 2 +@deco2(with_args=True) +# leading 3 +@deco3 +def decorated1(): ... + + +# leading 1 +@deco1 +# leading 2 +@deco2(with_args=True) +# leading function comment +def decorated1(): ... + + +some_instruction + + +# This comment should be split from `some_instruction` by two lines. +def g(): ... + + +if __name__ == "__main__": + main() diff --git a/tests/data/cases/comments6.py b/tests/data/cases/comments6.py new file mode 100644 index 0000000..735c6aa --- /dev/null +++ b/tests/data/cases/comments6.py @@ -0,0 +1,118 @@ +from typing import Any, Tuple + + +def f( + a, # type: int +): + pass + + +# test type comments +def f(a, b, c, d, e, f, g, h, i): + # type: (int, int, int, int, int, int, int, int, int) -> None + pass + + +def f( + a, # type: int + b, # type: int + c, # type: int + d, # type: int + e, # type: int + f, # type: int + g, # type: int + h, # type: int + i, # type: int +): + # type: (...) -> None + pass + + +def f( + arg, # type: int + *args, # type: *Any + default=False, # type: bool + **kwargs, # type: **Any +): + # type: (...) -> None + pass + + +def f( + a, # type: int + b, # type: int + c, # type: int + d, # type: int +): + # type: (...) -> None + + element = 0 # type: int + another_element = 1 # type: float + another_element_with_long_name = 2 # type: int + another_really_really_long_element_with_a_unnecessarily_long_name_to_describe_what_it_does_enterprise_style = ( + 3 + ) # type: int + an_element_with_a_long_value = calls() or more_calls() and more() # type: bool + + tup = ( + another_element, + another_really_really_long_element_with_a_unnecessarily_long_name_to_describe_what_it_does_enterprise_style, + ) # type: Tuple[int, int] + + a = ( + element + + another_element + + another_element_with_long_name + + element + + another_element + + another_element_with_long_name + ) # type: int + + +def f( + x, # not a type comment + y, # type: int +): + # type: (...) -> None + pass + + +def f( + x, # not a type comment +): # type: (int) -> None + pass + + +def func( + a=some_list[0], # type: int +): # type: () -> int + c = call( + 0.0123, + 0.0456, + 0.0789, + 0.0123, + 0.0456, + 0.0789, + 0.0123, + 0.0456, + 0.0789, + a[-1], # type: ignore + ) + + c = call( + "aaaaaaaa", "aaaaaaaa", "aaaaaaaa", "aaaaaaaa", "aaaaaaaa", "aaaaaaaa", "aaaaaaaa" # type: ignore + ) + + +result = ( # aaa + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +) + +AAAAAAAAAAAAA = [AAAAAAAAAAAAA] + SHARED_AAAAAAAAAAAAA + USER_AAAAAAAAAAAAA + AAAAAAAAAAAAA # type: ignore + +call_to_some_function_asdf( + foo, + [AAAAAAAAAAAAAAAAAAAAAAA, AAAAAAAAAAAAAAAAAAAAAAA, AAAAAAAAAAAAAAAAAAAAAAA, BBBBBBBBBBBB], # type: ignore +) + +aaaaaaaaaaaaa, bbbbbbbbb = map(list, map(itertools.chain.from_iterable, zip(*items))) # type: ignore[arg-type] diff --git a/tests/data/cases/comments8.py b/tests/data/cases/comments8.py new file mode 100644 index 0000000..a2030c2 --- /dev/null +++ b/tests/data/cases/comments8.py @@ -0,0 +1,15 @@ +# The percent-percent comments are Spyder IDE cells. +# Both `#%%`` and `# %%` are accepted, so `black` standardises +# to the latter. + +#%% +# %% + +# output + +# The percent-percent comments are Spyder IDE cells. +# Both `#%%`` and `# %%` are accepted, so `black` standardises +# to the latter. + +# %% +# %% diff --git a/tests/data/cases/comments9.py b/tests/data/cases/comments9.py new file mode 100644 index 0000000..77b2555 --- /dev/null +++ b/tests/data/cases/comments9.py @@ -0,0 +1,305 @@ +# Test for https://github.com/psf/black/issues/246. + +some = statement +# This comment should be split from the statement above by two lines. +def function(): + pass + + +some = statement +# This multiline comments section +# should be split from the statement +# above by two lines. +def function(): + pass + + +some = statement +# This comment should be split from the statement above by two lines. +async def async_function(): + pass + + +some = statement +# This comment should be split from the statement above by two lines. +class MyClass: + pass + + +some = statement +# This should be stick to the statement above + +# This should be split from the above by two lines +class MyClassWithComplexLeadingComments: + pass + + +class ClassWithDocstring: + """A docstring.""" +# Leading comment after a class with just a docstring +class MyClassAfterAnotherClassWithDocstring: + pass + + +some = statement +# leading 1 +@deco1 +# leading 2 +# leading 2 extra +@deco2(with_args=True) +# leading 3 +@deco3 +# leading 4 +def decorated(): + pass + + +some = statement +# leading 1 +@deco1 +# leading 2 +@deco2(with_args=True) + +# leading 3 that already has an empty line +@deco3 +# leading 4 +def decorated_with_split_leading_comments(): + pass + + +some = statement +# leading 1 +@deco1 +# leading 2 +@deco2(with_args=True) +# leading 3 +@deco3 + +# leading 4 that already has an empty line +def decorated_with_split_leading_comments(): + pass + + +def main(): + if a: + # Leading comment before inline function + def inline(): + pass + # Another leading comment + def another_inline(): + pass + else: + # More leading comments + def inline_after_else(): + pass + + +if a: + # Leading comment before "top-level inline" function + def top_level_quote_inline(): + pass + # Another leading comment + def another_top_level_quote_inline_inline(): + pass +else: + # More leading comments + def top_level_quote_inline_after_else(): + pass + + +class MyClass: + # First method has no empty lines between bare class def. + # More comments. + def first_method(self): + pass + + +# Regression test for https://github.com/psf/black/issues/3454. +def foo(): + pass + # Trailing comment that belongs to this function + + +@decorator1 +@decorator2 # fmt: skip +def bar(): + pass + + +# Regression test for https://github.com/psf/black/issues/3454. +def foo(): + pass + # Trailing comment that belongs to this function. + # NOTE this comment only has one empty line below, and the formatter + # should enforce two blank lines. + +@decorator1 +# A standalone comment +def bar(): + pass + + +# output + + +# Test for https://github.com/psf/black/issues/246. + +some = statement + + +# This comment should be split from the statement above by two lines. +def function(): + pass + + +some = statement + + +# This multiline comments section +# should be split from the statement +# above by two lines. +def function(): + pass + + +some = statement + + +# This comment should be split from the statement above by two lines. +async def async_function(): + pass + + +some = statement + + +# This comment should be split from the statement above by two lines. +class MyClass: + pass + + +some = statement +# This should be stick to the statement above + + +# This should be split from the above by two lines +class MyClassWithComplexLeadingComments: + pass + + +class ClassWithDocstring: + """A docstring.""" + + +# Leading comment after a class with just a docstring +class MyClassAfterAnotherClassWithDocstring: + pass + + +some = statement + + +# leading 1 +@deco1 +# leading 2 +# leading 2 extra +@deco2(with_args=True) +# leading 3 +@deco3 +# leading 4 +def decorated(): + pass + + +some = statement + + +# leading 1 +@deco1 +# leading 2 +@deco2(with_args=True) + +# leading 3 that already has an empty line +@deco3 +# leading 4 +def decorated_with_split_leading_comments(): + pass + + +some = statement + + +# leading 1 +@deco1 +# leading 2 +@deco2(with_args=True) +# leading 3 +@deco3 + +# leading 4 that already has an empty line +def decorated_with_split_leading_comments(): + pass + + +def main(): + if a: + # Leading comment before inline function + def inline(): + pass + + # Another leading comment + def another_inline(): + pass + + else: + # More leading comments + def inline_after_else(): + pass + + +if a: + # Leading comment before "top-level inline" function + def top_level_quote_inline(): + pass + + # Another leading comment + def another_top_level_quote_inline_inline(): + pass + +else: + # More leading comments + def top_level_quote_inline_after_else(): + pass + + +class MyClass: + # First method has no empty lines between bare class def. + # More comments. + def first_method(self): + pass + + +# Regression test for https://github.com/psf/black/issues/3454. +def foo(): + pass + # Trailing comment that belongs to this function + + +@decorator1 +@decorator2 # fmt: skip +def bar(): + pass + + +# Regression test for https://github.com/psf/black/issues/3454. +def foo(): + pass + # Trailing comment that belongs to this function. + # NOTE this comment only has one empty line below, and the formatter + # should enforce two blank lines. + + +@decorator1 +# A standalone comment +def bar(): + pass diff --git a/tests/data/cases/comments_in_blocks.py b/tests/data/cases/comments_in_blocks.py new file mode 100644 index 0000000..1221139 --- /dev/null +++ b/tests/data/cases/comments_in_blocks.py @@ -0,0 +1,111 @@ +# Test cases from: +# - https://github.com/psf/black/issues/1798 +# - https://github.com/psf/black/issues/1499 +# - https://github.com/psf/black/issues/1211 +# - https://github.com/psf/black/issues/563 + +( + lambda + # a comment + : None +) + +( + lambda: + # b comment + None +) + +( + lambda + # a comment + : + # b comment + None +) + +[ + x + # Let's do this + for + # OK? + x + # Some comment + # And another + in + # One more + y +] + +return [ + (offers[offer_index], 1.0) + for offer_index, _ + # avoid returning any offers that don't match the grammar so + # that the return values here are consistent with what would be + # returned in AcceptValidHeader + in self._parse_and_normalize_offers(offers) +] + +from foo import ( + bar, + # qux +) + + +def convert(collection): + # replace all variables by integers + replacement_dict = { + variable: f"{index}" + for index, variable + # 0 is reserved as line terminator + in enumerate(collection.variables(), start=1) + } + + +{ + i: i + for i + # a comment + in range(5) +} + + +def get_subtree_proof_nodes( + chunk_index_groups: Sequence[Tuple[int, ...], ...], +) -> Tuple[int, ...]: + subtree_node_paths = ( + # We take a candidate element from each group and shift it to + # remove the bits that are not common to other group members, then + # we convert it to a tree path that all elements from this group + # have in common. + chunk_index + for chunk_index, bits_to_truncate + # Each group will contain an even "power-of-two" number of# elements. + # This tells us how many tailing bits each element has# which need to + # be truncated to get the group's common prefix. + in ((group[0], (len(group) - 1).bit_length()) for group in chunk_index_groups) + ) + return subtree_node_paths + + +if ( + # comment1 + a + # comment2 + or ( + # comment3 + ( + # comment4 + b + ) + # comment5 + and + # comment6 + c + or ( + # comment7 + d + ) + ) +): + print("Foo") diff --git a/tests/data/cases/comments_in_comprehensions.py b/tests/data/cases/comments_in_comprehensions.py new file mode 100644 index 0000000..05d5858 --- /dev/null +++ b/tests/data/cases/comments_in_comprehensions.py @@ -0,0 +1,91 @@ +# Regression tests for https://github.com/psf/black/issues/4296. + +[ + x + for + # comment + x, y in ["AB",] +] + +[ + [ + x + for x + # comment + in [ + # comment + "ABC" + ] + ] +] + +{ + ( + lambda + # comment + x: [ + # comment + ] + ) +} + +async def f(): + return [ + x + async for + # comment + x, y in ["AB",] + ] + +for (a, b), c in [ + # comment + z, +]: + pass + +# output + +# Regression tests for https://github.com/psf/black/issues/4296. + +[ + x + for + # comment + x, y in [ + "AB", + ] +] + +[ + [x for x + # comment + in [ + # comment + "ABC"]] +] + +{ + lambda + # comment + x: [ + # comment + ] +} + + +async def f(): + return [ + x + async for + # comment + x, y in [ + "AB", + ] + ] + + +for (a, b), c in [ + # comment + z, +]: + pass diff --git a/tests/data/cases/comments_in_double_parens.py b/tests/data/cases/comments_in_double_parens.py new file mode 100644 index 0000000..80e7a5e --- /dev/null +++ b/tests/data/cases/comments_in_double_parens.py @@ -0,0 +1,113 @@ +if ( + True + # sdf +): + print("hw") + +if (( + True + # sdf +)): + print("hw") + +if (( + # type: ignore + True +)): + print("hw") + +if (( + True + # type: ignore +)): + print("hw") + +if ( + # a long comment about + # the condition below + (a or b) +): + pass + +def return_true(): + return ( + ( + True # this comment gets removed accidentally + ) + ) + +def return_true(): + return (True) # this comment gets removed accidentally + + +if ( + # huh comment + (True) +): + ... + +if ( + # huh + ( + # comment + True + ) +): + ... + + +# output + +if ( + True + # sdf +): + print("hw") + +if ( + True + # sdf +): + print("hw") + +if ( + # type: ignore + True +): + print("hw") + +if ( + True + # type: ignore +): + print("hw") + +if ( + # a long comment about + # the condition below + a + or b +): + pass + + +def return_true(): + return True # this comment gets removed accidentally + + +def return_true(): + return True # this comment gets removed accidentally + + +if ( + # huh comment + True +): + ... + +if ( + # huh + # comment + True +): + ... diff --git a/tests/data/cases/comments_in_lambda_default.py b/tests/data/cases/comments_in_lambda_default.py new file mode 100644 index 0000000..9aee769 --- /dev/null +++ b/tests/data/cases/comments_in_lambda_default.py @@ -0,0 +1,27 @@ +help(lambda x=( + # comment + "bar", +): False) + +result = (lambda x=( + # a standalone comment + 1, + 2, + 3, +): x) + +# output + +help( + lambda x=( + # comment + "bar", + ): False, +) + +result = lambda x=( + # a standalone comment + 1, + 2, + 3, +): x diff --git a/tests/data/cases/comments_non_breaking_space.py b/tests/data/cases/comments_non_breaking_space.py new file mode 100644 index 0000000..e17c3f4 --- /dev/null +++ b/tests/data/cases/comments_non_breaking_space.py @@ -0,0 +1,44 @@ +from .config import ( ConfigTypeAttributes, Int, Path, # String, + # DEFAULT_TYPE_ATTRIBUTES, +) + +result = 1 # A simple comment +result = ( 1, ) # Another one + +result = 1 # type: ignore +result = 1# This comment is talking about type: ignore +square = Square(4) # type: Optional[Square] + +def function(a:int=42): + """ This docstring is already formatted + a + b + """ + #  There's a NBSP + 3 spaces before + # And 4 spaces on the next line + pass + +# output +from .config import ( + ConfigTypeAttributes, + Int, + Path, # String, + # DEFAULT_TYPE_ATTRIBUTES, +) + +result = 1 # A simple comment +result = (1,) # Another one + +result = 1 #  type: ignore +result = 1 # This comment is talking about type: ignore +square = Square(4) #  type: Optional[Square] + + +def function(a: int = 42): + """This docstring is already formatted + a + b + """ + # There's a NBSP + 3 spaces before + # And 4 spaces on the next line + pass diff --git a/tests/data/cases/composition.py b/tests/data/cases/composition.py new file mode 100644 index 0000000..0798d3f --- /dev/null +++ b/tests/data/cases/composition.py @@ -0,0 +1,179 @@ +class C: + def test(self) -> None: + with patch("black.out", print): + self.assertEqual( + unstyle(str(report)), "1 file reformatted, 1 file failed to reformat." + ) + self.assertEqual( + unstyle(str(report)), + "1 file reformatted, 1 file left unchanged, 1 file failed to reformat.", + ) + self.assertEqual( + unstyle(str(report)), + "2 files reformatted, 1 file left unchanged, 1 file failed to" + " reformat.", + ) + self.assertEqual( + unstyle(str(report)), + "2 files reformatted, 2 files left unchanged, 2 files failed to" + " reformat.", + ) + for i in (a,): + if ( + # Rule 1 + i % 2 == 0 + # Rule 2 + and i % 3 == 0 + ): + while ( + # Just a comment + call() + # Another + ): + print(i) + xxxxxxxxxxxxxxxx = Yyyy2YyyyyYyyyyy( + push_manager=context.request.resource_manager, + max_items_to_push=num_items, + batch_size=Yyyy2YyyyYyyyyYyyy.FULL_SIZE, + ).push( + # Only send the first n items. + items=items[:num_items] + ) + return ( + 'Utterly failed doctest test for %s\n File "%s", line %s, in %s\n\n%s' + % (test.name, test.filename, lineno, lname, err) + ) + + def omitting_trailers(self) -> None: + get_collection( + hey_this_is_a_very_long_call, it_has_funny_attributes, really=True + )[OneLevelIndex] + get_collection( + hey_this_is_a_very_long_call, it_has_funny_attributes, really=True + )[OneLevelIndex][TwoLevelIndex][ThreeLevelIndex][FourLevelIndex] + d[0][1][2][3][4][5][6][7][8][9][10][11][12][13][14][15][16][17][18][19][20][21][ + 22 + ] + assignment = ( + some.rather.elaborate.rule() and another.rule.ending_with.index[123] + ) + + def easy_asserts(self) -> None: + assert { + key1: value1, + key2: value2, + key3: value3, + key4: value4, + key5: value5, + key6: value6, + key7: value7, + key8: value8, + key9: value9, + } == expected, "Not what we expected" + + assert expected == { + key1: value1, + key2: value2, + key3: value3, + key4: value4, + key5: value5, + key6: value6, + key7: value7, + key8: value8, + key9: value9, + }, "Not what we expected" + + assert expected == { + key1: value1, + key2: value2, + key3: value3, + key4: value4, + key5: value5, + key6: value6, + key7: value7, + key8: value8, + key9: value9, + } + + def tricky_asserts(self) -> None: + assert { + key1: value1, + key2: value2, + key3: value3, + key4: value4, + key5: value5, + key6: value6, + key7: value7, + key8: value8, + key9: value9, + } == expected( + value, is_going_to_be="too long to fit in a single line", srsly=True + ), "Not what we expected" + + assert { + key1: value1, + key2: value2, + key3: value3, + key4: value4, + key5: value5, + key6: value6, + key7: value7, + key8: value8, + key9: value9, + } == expected, ( + "Not what we expected and the message is too long to fit in one line" + ) + + assert expected( + value, is_going_to_be="too long to fit in a single line", srsly=True + ) == { + key1: value1, + key2: value2, + key3: value3, + key4: value4, + key5: value5, + key6: value6, + key7: value7, + key8: value8, + key9: value9, + }, "Not what we expected" + + assert expected == { + key1: value1, + key2: value2, + key3: value3, + key4: value4, + key5: value5, + key6: value6, + key7: value7, + key8: value8, + key9: value9, + }, ( + "Not what we expected and the message is too long to fit in one line" + " because it's too long" + ) + + dis_c_instance_method = """\ + %3d 0 LOAD_FAST 1 (x) + 2 LOAD_CONST 1 (1) + 4 COMPARE_OP 2 (==) + 6 LOAD_FAST 0 (self) + 8 STORE_ATTR 0 (x) + 10 LOAD_CONST 0 (None) + 12 RETURN_VALUE + """ % (_C.__init__.__code__.co_firstlineno + 1,) + + assert ( + expectedexpectedexpectedexpectedexpectedexpectedexpectedexpectedexpect + == { + key1: value1, + key2: value2, + key3: value3, + key4: value4, + key5: value5, + key6: value6, + key7: value7, + key8: value8, + key9: value9, + } + ) diff --git a/tests/data/cases/composition_no_trailing_comma.py b/tests/data/cases/composition_no_trailing_comma.py new file mode 100644 index 0000000..88d17b7 --- /dev/null +++ b/tests/data/cases/composition_no_trailing_comma.py @@ -0,0 +1,365 @@ +class C: + def test(self) -> None: + with patch("black.out", print): + self.assertEqual( + unstyle(str(report)), "1 file reformatted, 1 file failed to reformat." + ) + self.assertEqual( + unstyle(str(report)), + "1 file reformatted, 1 file left unchanged, 1 file failed to reformat.", + ) + self.assertEqual( + unstyle(str(report)), + "2 files reformatted, 1 file left unchanged, 1 file failed to" + " reformat.", + ) + self.assertEqual( + unstyle(str(report)), + "2 files reformatted, 2 files left unchanged, 2 files failed to" + " reformat.", + ) + for i in (a,): + if ( + # Rule 1 + i % 2 == 0 + # Rule 2 + and i % 3 == 0 + ): + while ( + # Just a comment + call() + # Another + ): + print(i) + xxxxxxxxxxxxxxxx = Yyyy2YyyyyYyyyyy( + push_manager=context.request.resource_manager, + max_items_to_push=num_items, + batch_size=Yyyy2YyyyYyyyyYyyy.FULL_SIZE + ).push( + # Only send the first n items. + items=items[:num_items] + ) + return ( + 'Utterly failed doctest test for %s\n File "%s", line %s, in %s\n\n%s' + % (test.name, test.filename, lineno, lname, err) + ) + + def omitting_trailers(self) -> None: + get_collection( + hey_this_is_a_very_long_call, it_has_funny_attributes, really=True + )[OneLevelIndex] + get_collection( + hey_this_is_a_very_long_call, it_has_funny_attributes, really=True + )[OneLevelIndex][TwoLevelIndex][ThreeLevelIndex][FourLevelIndex] + d[0][1][2][3][4][5][6][7][8][9][10][11][12][13][14][15][16][17][18][19][20][21][ + 22 + ] + assignment = ( + some.rather.elaborate.rule() and another.rule.ending_with.index[123] + ) + + def easy_asserts(self) -> None: + assert { + key1: value1, + key2: value2, + key3: value3, + key4: value4, + key5: value5, + key6: value6, + key7: value7, + key8: value8, + key9: value9 + } == expected, "Not what we expected" + + assert expected == { + key1: value1, + key2: value2, + key3: value3, + key4: value4, + key5: value5, + key6: value6, + key7: value7, + key8: value8, + key9: value9 + }, "Not what we expected" + + assert expected == { + key1: value1, + key2: value2, + key3: value3, + key4: value4, + key5: value5, + key6: value6, + key7: value7, + key8: value8, + key9: value9 + } + + def tricky_asserts(self) -> None: + assert { + key1: value1, + key2: value2, + key3: value3, + key4: value4, + key5: value5, + key6: value6, + key7: value7, + key8: value8, + key9: value9 + } == expected( + value, is_going_to_be="too long to fit in a single line", srsly=True + ), "Not what we expected" + + assert { + key1: value1, + key2: value2, + key3: value3, + key4: value4, + key5: value5, + key6: value6, + key7: value7, + key8: value8, + key9: value9 + } == expected, ( + "Not what we expected and the message is too long to fit in one line" + ) + + assert expected( + value, is_going_to_be="too long to fit in a single line", srsly=True + ) == { + key1: value1, + key2: value2, + key3: value3, + key4: value4, + key5: value5, + key6: value6, + key7: value7, + key8: value8, + key9: value9 + }, "Not what we expected" + + assert expected == { + key1: value1, + key2: value2, + key3: value3, + key4: value4, + key5: value5, + key6: value6, + key7: value7, + key8: value8, + key9: value9 + }, ( + "Not what we expected and the message is too long to fit in one line" + " because it's too long" + ) + + dis_c_instance_method = """\ + %3d 0 LOAD_FAST 1 (x) + 2 LOAD_CONST 1 (1) + 4 COMPARE_OP 2 (==) + 6 LOAD_FAST 0 (self) + 8 STORE_ATTR 0 (x) + 10 LOAD_CONST 0 (None) + 12 RETURN_VALUE + """ % ( + _C.__init__.__code__.co_firstlineno + 1, + ) + + assert ( + expectedexpectedexpectedexpectedexpectedexpectedexpectedexpectedexpect + == { + key1: value1, + key2: value2, + key3: value3, + key4: value4, + key5: value5, + key6: value6, + key7: value7, + key8: value8, + key9: value9 + } + ) + + + +# output + +class C: + def test(self) -> None: + with patch("black.out", print): + self.assertEqual( + unstyle(str(report)), "1 file reformatted, 1 file failed to reformat." + ) + self.assertEqual( + unstyle(str(report)), + "1 file reformatted, 1 file left unchanged, 1 file failed to reformat.", + ) + self.assertEqual( + unstyle(str(report)), + "2 files reformatted, 1 file left unchanged, 1 file failed to" + " reformat.", + ) + self.assertEqual( + unstyle(str(report)), + "2 files reformatted, 2 files left unchanged, 2 files failed to" + " reformat.", + ) + for i in (a,): + if ( + # Rule 1 + i % 2 == 0 + # Rule 2 + and i % 3 == 0 + ): + while ( + # Just a comment + call() + # Another + ): + print(i) + xxxxxxxxxxxxxxxx = Yyyy2YyyyyYyyyyy( + push_manager=context.request.resource_manager, + max_items_to_push=num_items, + batch_size=Yyyy2YyyyYyyyyYyyy.FULL_SIZE, + ).push( + # Only send the first n items. + items=items[:num_items] + ) + return ( + 'Utterly failed doctest test for %s\n File "%s", line %s, in %s\n\n%s' + % (test.name, test.filename, lineno, lname, err) + ) + + def omitting_trailers(self) -> None: + get_collection( + hey_this_is_a_very_long_call, it_has_funny_attributes, really=True + )[OneLevelIndex] + get_collection( + hey_this_is_a_very_long_call, it_has_funny_attributes, really=True + )[OneLevelIndex][TwoLevelIndex][ThreeLevelIndex][FourLevelIndex] + d[0][1][2][3][4][5][6][7][8][9][10][11][12][13][14][15][16][17][18][19][20][21][ + 22 + ] + assignment = ( + some.rather.elaborate.rule() and another.rule.ending_with.index[123] + ) + + def easy_asserts(self) -> None: + assert { + key1: value1, + key2: value2, + key3: value3, + key4: value4, + key5: value5, + key6: value6, + key7: value7, + key8: value8, + key9: value9, + } == expected, "Not what we expected" + + assert expected == { + key1: value1, + key2: value2, + key3: value3, + key4: value4, + key5: value5, + key6: value6, + key7: value7, + key8: value8, + key9: value9, + }, "Not what we expected" + + assert expected == { + key1: value1, + key2: value2, + key3: value3, + key4: value4, + key5: value5, + key6: value6, + key7: value7, + key8: value8, + key9: value9, + } + + def tricky_asserts(self) -> None: + assert { + key1: value1, + key2: value2, + key3: value3, + key4: value4, + key5: value5, + key6: value6, + key7: value7, + key8: value8, + key9: value9, + } == expected( + value, is_going_to_be="too long to fit in a single line", srsly=True + ), "Not what we expected" + + assert { + key1: value1, + key2: value2, + key3: value3, + key4: value4, + key5: value5, + key6: value6, + key7: value7, + key8: value8, + key9: value9, + } == expected, ( + "Not what we expected and the message is too long to fit in one line" + ) + + assert expected( + value, is_going_to_be="too long to fit in a single line", srsly=True + ) == { + key1: value1, + key2: value2, + key3: value3, + key4: value4, + key5: value5, + key6: value6, + key7: value7, + key8: value8, + key9: value9, + }, "Not what we expected" + + assert expected == { + key1: value1, + key2: value2, + key3: value3, + key4: value4, + key5: value5, + key6: value6, + key7: value7, + key8: value8, + key9: value9, + }, ( + "Not what we expected and the message is too long to fit in one line" + " because it's too long" + ) + + dis_c_instance_method = """\ + %3d 0 LOAD_FAST 1 (x) + 2 LOAD_CONST 1 (1) + 4 COMPARE_OP 2 (==) + 6 LOAD_FAST 0 (self) + 8 STORE_ATTR 0 (x) + 10 LOAD_CONST 0 (None) + 12 RETURN_VALUE + """ % (_C.__init__.__code__.co_firstlineno + 1,) + + assert ( + expectedexpectedexpectedexpectedexpectedexpectedexpectedexpectedexpect + == { + key1: value1, + key2: value2, + key3: value3, + key4: value4, + key5: value5, + key6: value6, + key7: value7, + key8: value8, + key9: value9, + } + ) diff --git a/tests/data/cases/conditional_expression.py b/tests/data/cases/conditional_expression.py new file mode 100644 index 0000000..f65d6fb --- /dev/null +++ b/tests/data/cases/conditional_expression.py @@ -0,0 +1,204 @@ +long_kwargs_single_line = my_function( + foo="test, this is a sample value", + bar=some_long_value_name_foo_bar_baz if some_boolean_variable else some_fallback_value_foo_bar_baz, + baz="hello, this is a another value", +) + +multiline_kwargs_indented = my_function( + foo="test, this is a sample value", + bar=some_long_value_name_foo_bar_baz + if some_boolean_variable + else some_fallback_value_foo_bar_baz, + baz="hello, this is a another value", +) + +imploding_kwargs = my_function( + foo="test, this is a sample value", + bar=a + if foo + else b, + baz="hello, this is a another value", +) + +imploding_line = ( + 1 + if 1 + 1 == 2 + else 0 +) + +exploding_line = "hello this is a slightly long string" if some_long_value_name_foo_bar_baz else "this one is a little shorter" + +positional_argument_test(some_long_value_name_foo_bar_baz if some_boolean_variable else some_fallback_value_foo_bar_baz) + +def weird_default_argument(x=some_long_value_name_foo_bar_baz + if SOME_CONSTANT + else some_fallback_value_foo_bar_baz): + pass + +nested = "hello this is a slightly long string" if (some_long_value_name_foo_bar_baz if + nesting_test_expressions else some_fallback_value_foo_bar_baz) \ + else "this one is a little shorter" + +generator_expression = ( + some_long_value_name_foo_bar_baz if some_boolean_variable else some_fallback_value_foo_bar_baz for some_boolean_variable in some_iterable +) + + +def limit_offset_sql(self, low_mark, high_mark): + """Return LIMIT/OFFSET SQL clause.""" + limit, offset = self._get_limit_offset_params(low_mark, high_mark) + return " ".join( + sql + for sql in ( + "LIMIT %d" % limit if limit else None, + ("OFFSET %d" % offset) if offset else None, + ) + if sql + ) + + +def something(): + clone._iterable_class = ( + NamedValuesListIterable + if named + else FlatValuesListIterable + if flat + else ValuesListIterable + ) + + +def foo(wait: bool = True): + # This comment is two + # lines long + + # This is only one + time.sleep(1) if wait else None + time.sleep(1) if wait else None + + # With newline above + time.sleep(1) if wait else None + # Without newline above + time.sleep(1) if wait else None + + +a = "".join( + ( + "", # comment + "" if True else "", + ) +) + +# output + +long_kwargs_single_line = my_function( + foo="test, this is a sample value", + bar=( + some_long_value_name_foo_bar_baz + if some_boolean_variable + else some_fallback_value_foo_bar_baz + ), + baz="hello, this is a another value", +) + +multiline_kwargs_indented = my_function( + foo="test, this is a sample value", + bar=( + some_long_value_name_foo_bar_baz + if some_boolean_variable + else some_fallback_value_foo_bar_baz + ), + baz="hello, this is a another value", +) + +imploding_kwargs = my_function( + foo="test, this is a sample value", + bar=a if foo else b, + baz="hello, this is a another value", +) + +imploding_line = 1 if 1 + 1 == 2 else 0 + +exploding_line = ( + "hello this is a slightly long string" + if some_long_value_name_foo_bar_baz + else "this one is a little shorter" +) + +positional_argument_test( + some_long_value_name_foo_bar_baz + if some_boolean_variable + else some_fallback_value_foo_bar_baz +) + + +def weird_default_argument( + x=( + some_long_value_name_foo_bar_baz + if SOME_CONSTANT + else some_fallback_value_foo_bar_baz + ), +): + pass + + +nested = ( + "hello this is a slightly long string" + if ( + some_long_value_name_foo_bar_baz + if nesting_test_expressions + else some_fallback_value_foo_bar_baz + ) + else "this one is a little shorter" +) + +generator_expression = ( + ( + some_long_value_name_foo_bar_baz + if some_boolean_variable + else some_fallback_value_foo_bar_baz + ) + for some_boolean_variable in some_iterable +) + + +def limit_offset_sql(self, low_mark, high_mark): + """Return LIMIT/OFFSET SQL clause.""" + limit, offset = self._get_limit_offset_params(low_mark, high_mark) + return " ".join( + sql + for sql in ( + "LIMIT %d" % limit if limit else None, + ("OFFSET %d" % offset) if offset else None, + ) + if sql + ) + + +def something(): + clone._iterable_class = ( + NamedValuesListIterable + if named + else FlatValuesListIterable if flat else ValuesListIterable + ) + + +def foo(wait: bool = True): + # This comment is two + # lines long + + # This is only one + time.sleep(1) if wait else None + time.sleep(1) if wait else None + + # With newline above + time.sleep(1) if wait else None + # Without newline above + time.sleep(1) if wait else None + + +a = "".join( + ( + "", # comment + "" if True else "", + ) +) diff --git a/tests/data/cases/context_managers_38.py b/tests/data/cases/context_managers_38.py new file mode 100644 index 0000000..f125cdf --- /dev/null +++ b/tests/data/cases/context_managers_38.py @@ -0,0 +1,54 @@ +with \ + make_context_manager1() as cm1, \ + make_context_manager2() as cm2, \ + make_context_manager3() as cm3, \ + make_context_manager4() as cm4 \ +: + pass + + +with \ + make_context_manager1() as cm1, \ + make_context_manager2(), \ + make_context_manager3() as cm3, \ + make_context_manager4() \ +: + pass + + +with \ + new_new_new1() as cm1, \ + new_new_new2() \ +: + pass + + +with mock.patch.object( + self.my_runner, "first_method", autospec=True +) as mock_run_adb, mock.patch.object( + self.my_runner, "second_method", autospec=True, return_value="foo" +): + pass + + +# output + + +with make_context_manager1() as cm1, make_context_manager2() as cm2, make_context_manager3() as cm3, make_context_manager4() as cm4: + pass + + +with make_context_manager1() as cm1, make_context_manager2(), make_context_manager3() as cm3, make_context_manager4(): + pass + + +with new_new_new1() as cm1, new_new_new2(): + pass + + +with mock.patch.object( + self.my_runner, "first_method", autospec=True +) as mock_run_adb, mock.patch.object( + self.my_runner, "second_method", autospec=True, return_value="foo" +): + pass diff --git a/tests/data/cases/context_managers_39.py b/tests/data/cases/context_managers_39.py new file mode 100644 index 0000000..7f1ee2d --- /dev/null +++ b/tests/data/cases/context_managers_39.py @@ -0,0 +1,185 @@ +with \ + make_context_manager1() as cm1, \ + make_context_manager2() as cm2, \ + make_context_manager3() as cm3, \ + make_context_manager4() as cm4 \ +: + pass + + +# Leading comment +with \ + make_context_manager1() as cm1, \ + make_context_manager2(), \ + make_context_manager3() as cm3, \ + make_context_manager4() \ +: + pass + + +with \ + new_new_new1() as cm1, \ + new_new_new2() \ +: + pass + + +with ( + new_new_new1() as cm1, + new_new_new2() +): + pass + + +# Leading comment. +with ( + # First comment. + new_new_new1() as cm1, + # Second comment. + new_new_new2() + # Last comment. +): + pass + + +with \ + this_is_a_very_long_call(looong_arg1=looong_value1, looong_arg2=looong_value2) as cm1, \ + this_is_a_very_long_call(looong_arg1=looong_value1, looong_arg2=looong_value2, looong_arg3=looong_value3, looong_arg4=looong_value4) as cm2 \ +: + pass + + +with mock.patch.object( + self.my_runner, "first_method", autospec=True +) as mock_run_adb, mock.patch.object( + self.my_runner, "second_method", autospec=True, return_value="foo" +): + pass + + +with xxxxxxxx.some_kind_of_method( + some_argument=[ + "first", + "second", + "third", + ] +).another_method() as cmd: + pass + + +async def func(): + async with \ + make_context_manager1() as cm1, \ + make_context_manager2() as cm2, \ + make_context_manager3() as cm3, \ + make_context_manager4() as cm4 \ + : + pass + + async with some_function( + argument1, argument2, argument3="some_value" + ) as some_cm, some_other_function( + argument1, argument2, argument3="some_value" + ): + pass + + + +# don't remove the brackets here, it changes the meaning of the code. +with (x, y) as z: + pass + + +# output + + +with ( + make_context_manager1() as cm1, + make_context_manager2() as cm2, + make_context_manager3() as cm3, + make_context_manager4() as cm4, +): + pass + + +# Leading comment +with ( + make_context_manager1() as cm1, + make_context_manager2(), + make_context_manager3() as cm3, + make_context_manager4(), +): + pass + + +with new_new_new1() as cm1, new_new_new2(): + pass + + +with new_new_new1() as cm1, new_new_new2(): + pass + + +# Leading comment. +with ( + # First comment. + new_new_new1() as cm1, + # Second comment. + new_new_new2(), + # Last comment. +): + pass + + +with ( + this_is_a_very_long_call( + looong_arg1=looong_value1, looong_arg2=looong_value2 + ) as cm1, + this_is_a_very_long_call( + looong_arg1=looong_value1, + looong_arg2=looong_value2, + looong_arg3=looong_value3, + looong_arg4=looong_value4, + ) as cm2, +): + pass + + +with ( + mock.patch.object(self.my_runner, "first_method", autospec=True) as mock_run_adb, + mock.patch.object( + self.my_runner, "second_method", autospec=True, return_value="foo" + ), +): + pass + + +with xxxxxxxx.some_kind_of_method( + some_argument=[ + "first", + "second", + "third", + ] +).another_method() as cmd: + pass + + +async def func(): + async with ( + make_context_manager1() as cm1, + make_context_manager2() as cm2, + make_context_manager3() as cm3, + make_context_manager4() as cm4, + ): + pass + + async with ( + some_function(argument1, argument2, argument3="some_value") as some_cm, + some_other_function(argument1, argument2, argument3="some_value"), + ): + pass + + +# don't remove the brackets here, it changes the meaning of the code. +with (x, y) as z: + pass diff --git a/tests/data/cases/context_managers_autodetect_310.py b/tests/data/cases/context_managers_autodetect_310.py new file mode 100644 index 0000000..80f2110 --- /dev/null +++ b/tests/data/cases/context_managers_autodetect_310.py @@ -0,0 +1,36 @@ +# flags: --minimum-version=3.10 +# This file uses pattern matching introduced in Python 3.10. + + +match http_code: + case 404: + print("Not found") + + +with \ + make_context_manager1() as cm1, \ + make_context_manager2() as cm2, \ + make_context_manager3() as cm3, \ + make_context_manager4() as cm4 \ +: + pass + + +# output + + +# This file uses pattern matching introduced in Python 3.10. + + +match http_code: + case 404: + print("Not found") + + +with ( + make_context_manager1() as cm1, + make_context_manager2() as cm2, + make_context_manager3() as cm3, + make_context_manager4() as cm4, +): + pass diff --git a/tests/data/cases/context_managers_autodetect_311.py b/tests/data/cases/context_managers_autodetect_311.py new file mode 100644 index 0000000..020c4ce --- /dev/null +++ b/tests/data/cases/context_managers_autodetect_311.py @@ -0,0 +1,38 @@ +# flags: --minimum-version=3.11 +# This file uses except* clause in Python 3.11. + + +try: + some_call() +except* Error as e: + pass + + +with \ + make_context_manager1() as cm1, \ + make_context_manager2() as cm2, \ + make_context_manager3() as cm3, \ + make_context_manager4() as cm4 \ +: + pass + + +# output + + +# This file uses except* clause in Python 3.11. + + +try: + some_call() +except* Error as e: + pass + + +with ( + make_context_manager1() as cm1, + make_context_manager2() as cm2, + make_context_manager3() as cm3, + make_context_manager4() as cm4, +): + pass diff --git a/tests/data/cases/context_managers_autodetect_38.py b/tests/data/cases/context_managers_autodetect_38.py new file mode 100644 index 0000000..79e438b --- /dev/null +++ b/tests/data/cases/context_managers_autodetect_38.py @@ -0,0 +1,46 @@ +# This file doesn't use any Python 3.9+ only grammars. + + +# Make sure parens around a single context manager don't get autodetected as +# Python 3.9+. +with (a): + pass + + +with \ + make_context_manager1() as cm1, \ + make_context_manager2() as cm2, \ + make_context_manager3() as cm3, \ + make_context_manager4() as cm4 \ +: + pass + + +with mock.patch.object( + self.my_runner, "first_method", autospec=True +) as mock_run_adb, mock.patch.object( + self.my_runner, "second_method", autospec=True, return_value="foo" +): + pass + + +# output +# This file doesn't use any Python 3.9+ only grammars. + + +# Make sure parens around a single context manager don't get autodetected as +# Python 3.9+. +with a: + pass + + +with make_context_manager1() as cm1, make_context_manager2() as cm2, make_context_manager3() as cm3, make_context_manager4() as cm4: + pass + + +with mock.patch.object( + self.my_runner, "first_method", autospec=True +) as mock_run_adb, mock.patch.object( + self.my_runner, "second_method", autospec=True, return_value="foo" +): + pass diff --git a/tests/data/cases/context_managers_autodetect_39.py b/tests/data/cases/context_managers_autodetect_39.py new file mode 100644 index 0000000..0d28f99 --- /dev/null +++ b/tests/data/cases/context_managers_autodetect_39.py @@ -0,0 +1,34 @@ +# This file uses parenthesized context managers introduced in Python 3.9. + + +with \ + make_context_manager1() as cm1, \ + make_context_manager2() as cm2, \ + make_context_manager3() as cm3, \ + make_context_manager4() as cm4 \ +: + pass + + +with ( + new_new_new1() as cm1, + new_new_new2() +): + pass + + +# output +# This file uses parenthesized context managers introduced in Python 3.9. + + +with ( + make_context_manager1() as cm1, + make_context_manager2() as cm2, + make_context_manager3() as cm3, + make_context_manager4() as cm4, +): + pass + + +with new_new_new1() as cm1, new_new_new2(): + pass diff --git a/tests/data/cases/docstring.py b/tests/data/cases/docstring.py new file mode 100644 index 0000000..462c296 --- /dev/null +++ b/tests/data/cases/docstring.py @@ -0,0 +1,457 @@ +class MyClass: + """ Multiline + class docstring + """ + + def method(self): + """Multiline + method docstring + """ + pass + + +def foo(): + """This is a docstring with + some lines of text here + """ + return + + +def bar(): + '''This is another docstring + with more lines of text + ''' + return + + +def baz(): + '''"This" is a string with some + embedded "quotes"''' + return + + +def troz(): + '''Indentation with tabs + is just as OK + ''' + return + + +def zort(): + """Another + multiline + docstring + """ + pass + +def poit(): + """ + Lorem ipsum dolor sit amet. + + Consectetur adipiscing elit: + - sed do eiusmod tempor incididunt ut labore + - dolore magna aliqua + - enim ad minim veniam + - quis nostrud exercitation ullamco laboris nisi + - aliquip ex ea commodo consequat + """ + pass + + +def under_indent(): + """ + These lines are indented in a way that does not +make sense. + """ + pass + + +def over_indent(): + """ + This has a shallow indent + - But some lines are deeper + - And the closing quote is too deep + """ + pass + + +def single_line(): + """But with a newline after it! + + """ + pass + + +def this(): + r""" + 'hey ho' + """ + + +def that(): + """ "hey yah" """ + + +def and_that(): + """ + "hey yah" """ + + +def and_this(): + ''' + "hey yah"''' + + +def multiline_whitespace(): + ''' + + + + + ''' + + +def oneline_whitespace(): + ''' ''' + + +def empty(): + """""" + + +def single_quotes(): + 'testing' + + +def believe_it_or_not_this_is_in_the_py_stdlib(): ''' +"hey yah"''' + + +def ignored_docstring(): + """a => \ +b""" + +def single_line_docstring_with_whitespace(): + """ This should be stripped """ + +def docstring_with_inline_tabs_and_space_indentation(): + """hey + + tab separated value + tab at start of line and then a tab separated value + multiple tabs at the beginning and inline + mixed tabs and spaces at beginning. next line has mixed tabs and spaces only. + + line ends with some tabs + """ + + +def docstring_with_inline_tabs_and_tab_indentation(): + """hey + + tab separated value + tab at start of line and then a tab separated value + multiple tabs at the beginning and inline + mixed tabs and spaces at beginning. next line has mixed tabs and spaces only. + + line ends with some tabs + """ + pass + + +def backslash_space(): + """\ """ + + +def multiline_backslash_1(): + ''' + hey\there\ + \ ''' + + +def multiline_backslash_2(): + ''' + hey there \ ''' + +# Regression test for #3425 +def multiline_backslash_really_long_dont_crash(): + """ + hey there hello guten tag hi hoow are you ola zdravstvuyte ciao como estas ca va \ """ + + +def multiline_backslash_3(): + ''' + already escaped \\ ''' + + +def my_god_its_full_of_stars_1(): + "I'm sorry Dave\u2001" + + +# the space below is actually a \u2001, removed in output +def my_god_its_full_of_stars_2(): + "I'm sorry Dave " + + +def docstring_almost_at_line_limit(): + """long docstring.................................................................""" + + +def docstring_almost_at_line_limit2(): + """long docstring................................................................. + + .................................................................................. + """ + + +def docstring_at_line_limit(): + """long docstring................................................................""" + + +def multiline_docstring_at_line_limit(): + """first line----------------------------------------------------------------------- + + second line----------------------------------------------------------------------""" + + +def stable_quote_normalization_with_immediate_inner_single_quote(self): + '''' + + + ''' + + +def foo(): + """ + Docstring with a backslash followed by a space\ + and then another line + """ + +# output + +class MyClass: + """Multiline + class docstring + """ + + def method(self): + """Multiline + method docstring + """ + pass + + +def foo(): + """This is a docstring with + some lines of text here + """ + return + + +def bar(): + """This is another docstring + with more lines of text + """ + return + + +def baz(): + '''"This" is a string with some + embedded "quotes"''' + return + + +def troz(): + """Indentation with tabs + is just as OK + """ + return + + +def zort(): + """Another + multiline + docstring + """ + pass + + +def poit(): + """ + Lorem ipsum dolor sit amet. + + Consectetur adipiscing elit: + - sed do eiusmod tempor incididunt ut labore + - dolore magna aliqua + - enim ad minim veniam + - quis nostrud exercitation ullamco laboris nisi + - aliquip ex ea commodo consequat + """ + pass + + +def under_indent(): + """ + These lines are indented in a way that does not + make sense. + """ + pass + + +def over_indent(): + """ + This has a shallow indent + - But some lines are deeper + - And the closing quote is too deep + """ + pass + + +def single_line(): + """But with a newline after it!""" + pass + + +def this(): + r""" + 'hey ho' + """ + + +def that(): + """ "hey yah" """ + + +def and_that(): + """ + "hey yah" """ + + +def and_this(): + ''' + "hey yah"''' + + +def multiline_whitespace(): + """ """ + + +def oneline_whitespace(): + """ """ + + +def empty(): + """""" + + +def single_quotes(): + "testing" + + +def believe_it_or_not_this_is_in_the_py_stdlib(): + ''' + "hey yah"''' + + +def ignored_docstring(): + """a => \ +b""" + + +def single_line_docstring_with_whitespace(): + """This should be stripped""" + + +def docstring_with_inline_tabs_and_space_indentation(): + """hey + + tab separated value + tab at start of line and then a tab separated value + multiple tabs at the beginning and inline + mixed tabs and spaces at beginning. next line has mixed tabs and spaces only. + + line ends with some tabs + """ + + +def docstring_with_inline_tabs_and_tab_indentation(): + """hey + + tab separated value + tab at start of line and then a tab separated value + multiple tabs at the beginning and inline + mixed tabs and spaces at beginning. next line has mixed tabs and spaces only. + + line ends with some tabs + """ + pass + + +def backslash_space(): + """\ """ + + +def multiline_backslash_1(): + """ + hey\there\ + \ """ + + +def multiline_backslash_2(): + """ + hey there \ """ + + +# Regression test for #3425 +def multiline_backslash_really_long_dont_crash(): + """ + hey there hello guten tag hi hoow are you ola zdravstvuyte ciao como estas ca va \ """ + + +def multiline_backslash_3(): + """ + already escaped \\""" + + +def my_god_its_full_of_stars_1(): + "I'm sorry Dave\u2001" + + +# the space below is actually a \u2001, removed in output +def my_god_its_full_of_stars_2(): + "I'm sorry Dave" + + +def docstring_almost_at_line_limit(): + """long docstring.................................................................""" + + +def docstring_almost_at_line_limit2(): + """long docstring................................................................. + + .................................................................................. + """ + + +def docstring_at_line_limit(): + """long docstring................................................................""" + + +def multiline_docstring_at_line_limit(): + """first line----------------------------------------------------------------------- + + second line----------------------------------------------------------------------""" + + +def stable_quote_normalization_with_immediate_inner_single_quote(self): + """' + + + """ + + +def foo(): + """ + Docstring with a backslash followed by a space\ + and then another line + """ diff --git a/tests/data/cases/docstring2.py b/tests/data/cases/docstring2.py new file mode 100644 index 0000000..a3c656b --- /dev/null +++ b/tests/data/cases/docstring2.py @@ -0,0 +1,104 @@ +def docstring_almost_at_line_limit(): + """long docstring................................................................. + """ + + +def docstring_almost_at_line_limit_with_prefix(): + f"""long docstring................................................................ + """ + + +def mulitline_docstring_almost_at_line_limit(): + """long docstring................................................................. + + .................................................................................. + """ + + +def mulitline_docstring_almost_at_line_limit_with_prefix(): + f"""long docstring................................................................ + + .................................................................................. + """ + + +def docstring_at_line_limit(): + """long docstring................................................................""" + + +def docstring_at_line_limit_with_prefix(): + f"""long docstring...............................................................""" + + +def multiline_docstring_at_line_limit(): + """first line----------------------------------------------------------------------- + + second line----------------------------------------------------------------------""" + + +def multiline_docstring_at_line_limit_with_prefix(): + f"""first line---------------------------------------------------------------------- + + second line----------------------------------------------------------------------""" + + +def single_quote_docstring_over_line_limit(): + "We do not want to put the closing quote on a new line as that is invalid (see GH-3141)." + + +def single_quote_docstring_over_line_limit2(): + 'We do not want to put the closing quote on a new line as that is invalid (see GH-3141).' + + +# output + + +def docstring_almost_at_line_limit(): + """long docstring.................................................................""" + + +def docstring_almost_at_line_limit_with_prefix(): + f"""long docstring................................................................ + """ + + +def mulitline_docstring_almost_at_line_limit(): + """long docstring................................................................. + + .................................................................................. + """ + + +def mulitline_docstring_almost_at_line_limit_with_prefix(): + f"""long docstring................................................................ + + .................................................................................. + """ + + +def docstring_at_line_limit(): + """long docstring................................................................""" + + +def docstring_at_line_limit_with_prefix(): + f"""long docstring...............................................................""" + + +def multiline_docstring_at_line_limit(): + """first line----------------------------------------------------------------------- + + second line----------------------------------------------------------------------""" + + +def multiline_docstring_at_line_limit_with_prefix(): + f"""first line---------------------------------------------------------------------- + + second line----------------------------------------------------------------------""" + + +def single_quote_docstring_over_line_limit(): + "We do not want to put the closing quote on a new line as that is invalid (see GH-3141)." + + +def single_quote_docstring_over_line_limit2(): + "We do not want to put the closing quote on a new line as that is invalid (see GH-3141)." diff --git a/tests/data/cases/docstring_newline.py b/tests/data/cases/docstring_newline.py new file mode 100644 index 0000000..75b8db4 --- /dev/null +++ b/tests/data/cases/docstring_newline.py @@ -0,0 +1,3 @@ +""" +87 characters ............................................................................ +""" diff --git a/tests/data/cases/docstring_no_extra_empty_line_before_eof.py b/tests/data/cases/docstring_no_extra_empty_line_before_eof.py new file mode 100644 index 0000000..6fea860 --- /dev/null +++ b/tests/data/cases/docstring_no_extra_empty_line_before_eof.py @@ -0,0 +1,4 @@ +# Make sure when the file ends with class's docstring, +# It doesn't add extra blank lines. +class ClassWithDocstring: + """A docstring.""" diff --git a/tests/data/cases/docstring_no_string_normalization.py b/tests/data/cases/docstring_no_string_normalization.py new file mode 100644 index 0000000..4ec6b8a --- /dev/null +++ b/tests/data/cases/docstring_no_string_normalization.py @@ -0,0 +1,250 @@ +# flags: --skip-string-normalization +class ALonelyClass: + ''' + A multiline class docstring. + ''' + def AnEquallyLonelyMethod(self): + ''' + A multiline method docstring''' + pass + + +def one_function(): + '''This is a docstring with a single line of text.''' + pass + + +def shockingly_the_quotes_are_normalized(): + '''This is a multiline docstring. + This is a multiline docstring. + This is a multiline docstring. + ''' + pass + + +def foo(): + """This is a docstring with + some lines of text here + """ + return + + +def baz(): + '''"This" is a string with some + embedded "quotes"''' + return + + +def poit(): + """ + Lorem ipsum dolor sit amet. + + Consectetur adipiscing elit: + - sed do eiusmod tempor incididunt ut labore + - dolore magna aliqua + - enim ad minim veniam + - quis nostrud exercitation ullamco laboris nisi + - aliquip ex ea commodo consequat + """ + pass + + +def under_indent(): + """ + These lines are indented in a way that does not +make sense. + """ + pass + + +def over_indent(): + """ + This has a shallow indent + - But some lines are deeper + - And the closing quote is too deep + """ + pass + + +def single_line(): + """But with a newline after it! + + """ + pass + + +def this(): + r""" + 'hey ho' + """ + + +def that(): + """ "hey yah" """ + + +def and_that(): + """ + "hey yah" """ + + +def and_this(): + ''' + "hey yah"''' + + +def believe_it_or_not_this_is_in_the_py_stdlib(): ''' +"hey yah"''' + + +def shockingly_the_quotes_are_normalized_v2(): + ''' + Docstring Docstring Docstring + ''' + pass + + +def backslash_space(): + '\ ' + + +def multiline_backslash_1(): + ''' + hey\there\ + \ ''' + + +def multiline_backslash_2(): + ''' + hey there \ ''' + + +def multiline_backslash_3(): + ''' + already escaped \\ ''' + +# output + +class ALonelyClass: + ''' + A multiline class docstring. + ''' + + def AnEquallyLonelyMethod(self): + ''' + A multiline method docstring''' + pass + + +def one_function(): + '''This is a docstring with a single line of text.''' + pass + + +def shockingly_the_quotes_are_normalized(): + '''This is a multiline docstring. + This is a multiline docstring. + This is a multiline docstring. + ''' + pass + + +def foo(): + """This is a docstring with + some lines of text here + """ + return + + +def baz(): + '''"This" is a string with some + embedded "quotes"''' + return + + +def poit(): + """ + Lorem ipsum dolor sit amet. + + Consectetur adipiscing elit: + - sed do eiusmod tempor incididunt ut labore + - dolore magna aliqua + - enim ad minim veniam + - quis nostrud exercitation ullamco laboris nisi + - aliquip ex ea commodo consequat + """ + pass + + +def under_indent(): + """ + These lines are indented in a way that does not + make sense. + """ + pass + + +def over_indent(): + """ + This has a shallow indent + - But some lines are deeper + - And the closing quote is too deep + """ + pass + + +def single_line(): + """But with a newline after it!""" + pass + + +def this(): + r""" + 'hey ho' + """ + + +def that(): + """ "hey yah" """ + + +def and_that(): + """ + "hey yah" """ + + +def and_this(): + ''' + "hey yah"''' + + +def believe_it_or_not_this_is_in_the_py_stdlib(): + ''' + "hey yah"''' + + +def shockingly_the_quotes_are_normalized_v2(): + ''' + Docstring Docstring Docstring + ''' + pass + + +def backslash_space(): + '\ ' + + +def multiline_backslash_1(): + ''' + hey\there\ + \ ''' + + +def multiline_backslash_2(): + ''' + hey there \ ''' + + +def multiline_backslash_3(): + ''' + already escaped \\''' diff --git a/tests/data/cases/docstring_tabs.py b/tests/data/cases/docstring_tabs.py new file mode 100644 index 0000000..d5152ee --- /dev/null +++ b/tests/data/cases/docstring_tabs.py @@ -0,0 +1,24 @@ +def test(): + """ + Test of indentation + Testing indentation + Yes this is testing + Testing again + Shocking! + Wow! + More interesting information + """ + + +# output + +def test(): + """ + Test of indentation + Testing indentation + Yes this is testing + Testing again + Shocking! + Wow! + More interesting information + """ diff --git a/tests/data/cases/dummy_implementations.py b/tests/data/cases/dummy_implementations.py new file mode 100644 index 0000000..107bc2c --- /dev/null +++ b/tests/data/cases/dummy_implementations.py @@ -0,0 +1,249 @@ +from typing import NoReturn, Protocol, Union, overload + +class Empty: + ... + +def dummy(a): ... +async def other(b): ... + + +@overload +def a(arg: int) -> int: ... +@overload +def a(arg: str) -> str: ... +@overload +def a(arg: object) -> NoReturn: ... +def a(arg: Union[int, str, object]) -> Union[int, str]: + if not isinstance(arg, (int, str)): + raise TypeError + return arg + +class Proto(Protocol): + def foo(self, a: int) -> int: + ... + + def bar(self, b: str) -> str: ... + def baz(self, c: bytes) -> str: + ... + + +def dummy_two(): + ... +@dummy +def dummy_three(): + ... + +def dummy_four(): + ... + +@overload +def b(arg: int) -> int: ... + +@overload +def b(arg: str) -> str: ... +@overload +def b(arg: object) -> NoReturn: ... + +def b(arg: Union[int, str, object]) -> Union[int, str]: + if not isinstance(arg, (int, str)): + raise TypeError + return arg + +def has_comment(): + ... # still a dummy + +if some_condition: + ... + +if already_dummy: ... + +class AsyncCls: + async def async_method(self): + ... + +async def async_function(self): + ... + +@decorated +async def async_function(self): + ... + +class ClassA: + def f(self): + + ... + + +class ClassB: + def f(self): + + + + + + + + + + ... + + +class ClassC: + def f(self): + + ... + # Comment + + +class ClassD: + def f(self):# Comment 1 + + ...# Comment 2 + # Comment 3 + + +class ClassE: + def f(self): + + ... + def f2(self): + print(10) + + +class ClassF: + def f(self): + + ...# Comment 2 + + +class ClassG: + def f(self):#Comment 1 + + ...# Comment 2 + + +class ClassH: + def f(self): + #Comment + + ... + + +# output + +from typing import NoReturn, Protocol, Union, overload + + +class Empty: ... + + +def dummy(a): ... +async def other(b): ... + + +@overload +def a(arg: int) -> int: ... +@overload +def a(arg: str) -> str: ... +@overload +def a(arg: object) -> NoReturn: ... +def a(arg: Union[int, str, object]) -> Union[int, str]: + if not isinstance(arg, (int, str)): + raise TypeError + return arg + + +class Proto(Protocol): + def foo(self, a: int) -> int: ... + + def bar(self, b: str) -> str: ... + def baz(self, c: bytes) -> str: ... + + +def dummy_two(): ... +@dummy +def dummy_three(): ... + + +def dummy_four(): ... + + +@overload +def b(arg: int) -> int: ... + + +@overload +def b(arg: str) -> str: ... +@overload +def b(arg: object) -> NoReturn: ... + + +def b(arg: Union[int, str, object]) -> Union[int, str]: + if not isinstance(arg, (int, str)): + raise TypeError + return arg + + +def has_comment(): ... # still a dummy + + +if some_condition: + ... + +if already_dummy: + ... + + +class AsyncCls: + async def async_method(self): ... + + +async def async_function(self): ... + + +@decorated +async def async_function(self): ... + + +class ClassA: + def f(self): ... + + +class ClassB: + def f(self): ... + + +class ClassC: + def f(self): + + ... + # Comment + + +class ClassD: + def f(self): # Comment 1 + + ... # Comment 2 + # Comment 3 + + +class ClassE: + def f(self): ... + def f2(self): + print(10) + + +class ClassF: + def f(self): ... # Comment 2 + + +class ClassG: + def f(self): # Comment 1 + ... # Comment 2 + + +class ClassH: + def f(self): + # Comment + + ... diff --git a/tests/data/cases/empty_lines.py b/tests/data/cases/empty_lines.py new file mode 100644 index 0000000..4c03e43 --- /dev/null +++ b/tests/data/cases/empty_lines.py @@ -0,0 +1,187 @@ +"""Docstring.""" + + +# leading comment +def f(): + NO = '' + SPACE = ' ' + DOUBLESPACE = ' ' + + t = leaf.type + p = leaf.parent # trailing comment + v = leaf.value + + if t in ALWAYS_NO_SPACE: + pass + if t == token.COMMENT: # another trailing comment + return DOUBLESPACE + + + assert p is not None, f"INTERNAL ERROR: hand-made leaf without parent: {leaf!r}" + + + prev = leaf.prev_sibling + if not prev: + prevp = preceding_leaf(p) + if not prevp or prevp.type in OPENING_BRACKETS: + + + return NO + + + if prevp.type == token.EQUAL: + if prevp.parent and prevp.parent.type in { + syms.typedargslist, + syms.varargslist, + syms.parameters, + syms.arglist, + syms.argument, + }: + return NO + + elif prevp.type == token.DOUBLESTAR: + if prevp.parent and prevp.parent.type in { + syms.typedargslist, + syms.varargslist, + syms.parameters, + syms.arglist, + syms.dictsetmaker, + }: + return NO + +############################################################################### +# SECTION BECAUSE SECTIONS +############################################################################### + +def g(): + NO = '' + SPACE = ' ' + DOUBLESPACE = ' ' + + t = leaf.type + p = leaf.parent + v = leaf.value + + # Comment because comments + + if t in ALWAYS_NO_SPACE: + pass + if t == token.COMMENT: + return DOUBLESPACE + + # Another comment because more comments + assert p is not None, f'INTERNAL ERROR: hand-made leaf without parent: {leaf!r}' + + prev = leaf.prev_sibling + if not prev: + prevp = preceding_leaf(p) + + if not prevp or prevp.type in OPENING_BRACKETS: + # Start of the line or a bracketed expression. + # More than one line for the comment. + return NO + + if prevp.type == token.EQUAL: + if prevp.parent and prevp.parent.type in { + syms.typedargslist, + syms.varargslist, + syms.parameters, + syms.arglist, + syms.argument, + }: + return NO + + +# output + + +"""Docstring.""" + + +# leading comment +def f(): + NO = "" + SPACE = " " + DOUBLESPACE = " " + + t = leaf.type + p = leaf.parent # trailing comment + v = leaf.value + + if t in ALWAYS_NO_SPACE: + pass + if t == token.COMMENT: # another trailing comment + return DOUBLESPACE + + assert p is not None, f"INTERNAL ERROR: hand-made leaf without parent: {leaf!r}" + + prev = leaf.prev_sibling + if not prev: + prevp = preceding_leaf(p) + if not prevp or prevp.type in OPENING_BRACKETS: + + return NO + + if prevp.type == token.EQUAL: + if prevp.parent and prevp.parent.type in { + syms.typedargslist, + syms.varargslist, + syms.parameters, + syms.arglist, + syms.argument, + }: + return NO + + elif prevp.type == token.DOUBLESTAR: + if prevp.parent and prevp.parent.type in { + syms.typedargslist, + syms.varargslist, + syms.parameters, + syms.arglist, + syms.dictsetmaker, + }: + return NO + + +############################################################################### +# SECTION BECAUSE SECTIONS +############################################################################### + + +def g(): + NO = "" + SPACE = " " + DOUBLESPACE = " " + + t = leaf.type + p = leaf.parent + v = leaf.value + + # Comment because comments + + if t in ALWAYS_NO_SPACE: + pass + if t == token.COMMENT: + return DOUBLESPACE + + # Another comment because more comments + assert p is not None, f"INTERNAL ERROR: hand-made leaf without parent: {leaf!r}" + + prev = leaf.prev_sibling + if not prev: + prevp = preceding_leaf(p) + + if not prevp or prevp.type in OPENING_BRACKETS: + # Start of the line or a bracketed expression. + # More than one line for the comment. + return NO + + if prevp.type == token.EQUAL: + if prevp.parent and prevp.parent.type in { + syms.typedargslist, + syms.varargslist, + syms.parameters, + syms.arglist, + syms.argument, + }: + return NO diff --git a/tests/data/cases/expression.diff b/tests/data/cases/expression.diff new file mode 100644 index 0000000..2eaaeb4 --- /dev/null +++ b/tests/data/cases/expression.diff @@ -0,0 +1,466 @@ +--- [Deterministic header] ++++ [Deterministic header] +@@ -1,8 +1,8 @@ + ... +-'some_string' +-b'\\xa3' ++"some_string" ++b"\\xa3" + Name + None + True + False + 1 +@@ -21,99 +21,135 @@ + Name1 or (Name2 and Name3) or Name4 + Name1 or Name2 and Name3 or Name4 + v1 << 2 + 1 >> v2 + 1 % finished +-1 + v2 - v3 * 4 ^ 5 ** v6 / 7 // 8 +-((1 + v2) - (v3 * 4)) ^ (((5 ** v6) / 7) // 8) ++1 + v2 - v3 * 4 ^ 5**v6 / 7 // 8 ++((1 + v2) - (v3 * 4)) ^ (((5**v6) / 7) // 8) + not great + ~great + +value + -1 + ~int and not v1 ^ 123 + v2 | True + (~int) and (not ((v1 ^ (123 + v2)) | True)) +-+really ** -confusing ** ~operator ** -precedence +-flags & ~ select.EPOLLIN and waiters.write_task is not None +++(really ** -(confusing ** ~(operator**-precedence))) ++flags & ~select.EPOLLIN and waiters.write_task is not None + lambda arg: None + lambda a=True: a + lambda a, b, c=True: a +-lambda a, b, c=True, *, d=(1 << v2), e='str': a +-lambda a, b, c=True, *vararg, d=(v1 << 2), e='str', **kwargs: a + b ++lambda a, b, c=True, *, d=(1 << v2), e="str": a ++lambda a, b, c=True, *vararg, d=(v1 << 2), e="str", **kwargs: a + b + manylambdas = lambda x=lambda y=lambda z=1: z: y(): x() +-foo = (lambda port_id, ignore_missing: {"port1": port1_resource, "port2": port2_resource}[port_id]) ++foo = lambda port_id, ignore_missing: { ++ "port1": port1_resource, ++ "port2": port2_resource, ++}[port_id] + 1 if True else 2 + str or None if True else str or bytes or None + (str or None) if True else (str or bytes or None) + str or None if (1 if True else 2) else str or bytes or None + (str or None) if (1 if True else 2) else (str or bytes or None) +-((super_long_variable_name or None) if (1 if super_long_test_name else 2) else (str or bytes or None)) +-{'2.7': dead, '3.7': (long_live or die_hard)} +-{'2.7': dead, '3.7': (long_live or die_hard), **{'3.6': verygood}} ++( ++ (super_long_variable_name or None) ++ if (1 if super_long_test_name else 2) ++ else (str or bytes or None) ++) ++{"2.7": dead, "3.7": (long_live or die_hard)} ++{"2.7": dead, "3.7": (long_live or die_hard), **{"3.6": verygood}} + {**a, **b, **c} +-{'2.7', '3.6', '3.7', '3.8', '3.9', ('4.0' if gilectomy else '3.10')} +-({'a': 'b'}, (True or False), (+value), 'string', b'bytes') or None ++{"2.7", "3.6", "3.7", "3.8", "3.9", ("4.0" if gilectomy else "3.10")} ++({"a": "b"}, (True or False), (+value), "string", b"bytes") or None + () + (1,) + (1, 2) + (1, 2, 3) + [] + [1, 2, 3, 4, 5, 6, 7, 8, 9, (10 or A), (11 or B), (12 or C)] +-[1, 2, 3,] ++[ ++ 1, ++ 2, ++ 3, ++] + [*a] + [*range(10)] +-[*a, 4, 5,] +-[4, *a, 5,] +-[this_is_a_very_long_variable_which_will_force_a_delimiter_split, element, another, *more] ++[ ++ *a, ++ 4, ++ 5, ++] ++[ ++ 4, ++ *a, ++ 5, ++] ++[ ++ this_is_a_very_long_variable_which_will_force_a_delimiter_split, ++ element, ++ another, ++ *more, ++] + {i for i in (1, 2, 3)} +-{(i ** 2) for i in (1, 2, 3)} +-{(i ** 2) for i, _ in ((1, 'a'), (2, 'b'), (3, 'c'))} +-{((i ** 2) + j) for i in (1, 2, 3) for j in (1, 2, 3)} ++{(i**2) for i in (1, 2, 3)} ++{(i**2) for i, _ in ((1, "a"), (2, "b"), (3, "c"))} ++{((i**2) + j) for i in (1, 2, 3) for j in (1, 2, 3)} + [i for i in (1, 2, 3)] +-[(i ** 2) for i in (1, 2, 3)] +-[(i ** 2) for i, _ in ((1, 'a'), (2, 'b'), (3, 'c'))] +-[((i ** 2) + j) for i in (1, 2, 3) for j in (1, 2, 3)] ++[(i**2) for i in (1, 2, 3)] ++[(i**2) for i, _ in ((1, "a"), (2, "b"), (3, "c"))] ++[((i**2) + j) for i in (1, 2, 3) for j in (1, 2, 3)] + {i: 0 for i in (1, 2, 3)} +-{i: j for i, j in ((1, 'a'), (2, 'b'), (3, 'c'))} ++{i: j for i, j in ((1, "a"), (2, "b"), (3, "c"))} + {a: b * 2 for a, b in dictionary.items()} + {a: b * -2 for a, b in dictionary.items()} +-{k: v for k, v in this_is_a_very_long_variable_which_will_cause_a_trailing_comma_which_breaks_the_comprehension} ++{ ++ k: v ++ for k, v in this_is_a_very_long_variable_which_will_cause_a_trailing_comma_which_breaks_the_comprehension ++} + Python3 > Python2 > COBOL + Life is Life + call() + call(arg) +-call(kwarg='hey') +-call(arg, kwarg='hey') +-call(arg, another, kwarg='hey', **kwargs) +-call(this_is_a_very_long_variable_which_will_force_a_delimiter_split, arg, another, kwarg='hey', **kwargs) # note: no trailing comma pre-3.6 ++call(kwarg="hey") ++call(arg, kwarg="hey") ++call(arg, another, kwarg="hey", **kwargs) ++call( ++ this_is_a_very_long_variable_which_will_force_a_delimiter_split, ++ arg, ++ another, ++ kwarg="hey", ++ **kwargs ++) # note: no trailing comma pre-3.6 + call(*gidgets[:2]) + call(a, *gidgets[:2]) + call(**self.screen_kwargs) + call(b, **self.screen_kwargs) + lukasz.langa.pl + call.me(maybe) +-1 .real +-1.0 .real ++(1).real ++(1.0).real + ....__class__ + list[str] + dict[str, int] + tuple[str, ...] ++tuple[str, int, float, dict[str, int]] + tuple[ +- str, int, float, dict[str, int] +-] +-tuple[str, int, float, dict[str, int],] ++ str, ++ int, ++ float, ++ dict[str, int], ++] + very_long_variable_name_filters: t.List[ + t.Tuple[str, t.Union[str, t.List[t.Optional[str]]]], + ] + xxxx_xxxxx_xxxx_xxx: Callable[..., List[SomeClass]] = classmethod( # type: ignore + sync(async_xxxx_xxx_xxxx_xxxxx_xxxx_xxx.__func__) + ) + xxxx_xxx_xxxx_xxxxx_xxxx_xxx: Callable[..., List[SomeClass]] = classmethod( # type: ignore + sync(async_xxxx_xxx_xxxx_xxxxx_xxxx_xxx.__func__) + ) +-xxxx_xxx_xxxx_xxxxx_xxxx_xxx: Callable[ +- ..., List[SomeClass] +-] = classmethod(sync(async_xxxx_xxx_xxxx_xxxxx_xxxx_xxx.__func__)) # type: ignore ++xxxx_xxx_xxxx_xxxxx_xxxx_xxx: Callable[..., List[SomeClass]] = classmethod( ++ sync(async_xxxx_xxx_xxxx_xxxxx_xxxx_xxx.__func__) ++) # type: ignore + slice[0] + slice[0:1] + slice[0:1:2] + slice[:] + slice[:-1] +@@ -137,118 +173,199 @@ + numpy[-(c + 1) :, d] + numpy[:, l[-2]] + numpy[:, ::-1] + numpy[np.newaxis, :] + (str or None) if (sys.version_info[0] > (3,)) else (str or bytes or None) +-{'2.7': dead, '3.7': long_live or die_hard} +-{'2.7', '3.6', '3.7', '3.8', '3.9', '4.0' if gilectomy else '3.10'} ++{"2.7": dead, "3.7": long_live or die_hard} ++{"2.7", "3.6", "3.7", "3.8", "3.9", "4.0" if gilectomy else "3.10"} + [1, 2, 3, 4, 5, 6, 7, 8, 9, 10 or A, 11 or B, 12 or C] + (SomeName) + SomeName + (Good, Bad, Ugly) + (i for i in (1, 2, 3)) +-((i ** 2) for i in (1, 2, 3)) +-((i ** 2) for i, _ in ((1, 'a'), (2, 'b'), (3, 'c'))) +-(((i ** 2) + j) for i in (1, 2, 3) for j in (1, 2, 3)) ++((i**2) for i in (1, 2, 3)) ++((i**2) for i, _ in ((1, "a"), (2, "b"), (3, "c"))) ++(((i**2) + j) for i in (1, 2, 3) for j in (1, 2, 3)) + (*starred,) +-{"id": "1","type": "type","started_at": now(),"ended_at": now() + timedelta(days=10),"priority": 1,"import_session_id": 1,**kwargs} ++{ ++ "id": "1", ++ "type": "type", ++ "started_at": now(), ++ "ended_at": now() + timedelta(days=10), ++ "priority": 1, ++ "import_session_id": 1, ++ **kwargs, ++} + a = (1,) +-b = 1, ++b = (1,) + c = 1 + d = (1,) + a + (2,) + e = (1,).count(1) + f = 1, *range(10) + g = 1, *"ten" +-what_is_up_with_those_new_coord_names = (coord_names + set(vars_to_create)) + set(vars_to_remove) +-what_is_up_with_those_new_coord_names = (coord_names | set(vars_to_create)) - set(vars_to_remove) +-result = session.query(models.Customer.id).filter(models.Customer.account_id == account_id, models.Customer.email == email_address).order_by(models.Customer.id.asc()).all() +-result = session.query(models.Customer.id).filter(models.Customer.account_id == account_id, models.Customer.email == email_address).order_by(models.Customer.id.asc(),).all() ++what_is_up_with_those_new_coord_names = (coord_names + set(vars_to_create)) + set( ++ vars_to_remove ++) ++what_is_up_with_those_new_coord_names = (coord_names | set(vars_to_create)) - set( ++ vars_to_remove ++) ++result = ( ++ session.query(models.Customer.id) ++ .filter( ++ models.Customer.account_id == account_id, models.Customer.email == email_address ++ ) ++ .order_by(models.Customer.id.asc()) ++ .all() ++) ++result = ( ++ session.query(models.Customer.id) ++ .filter( ++ models.Customer.account_id == account_id, models.Customer.email == email_address ++ ) ++ .order_by( ++ models.Customer.id.asc(), ++ ) ++ .all() ++) + Ø = set() + authors.łukasz.say_thanks() + mapping = { + A: 0.25 * (10.0 / 12), + B: 0.1 * (10.0 / 12), + C: 0.1 * (10.0 / 12), + D: 0.1 * (10.0 / 12), + } + ++ + def gen(): + yield from outside_of_generator +- a = (yield) +- b = ((yield)) +- c = (((yield))) ++ a = yield ++ b = yield ++ c = yield ++ + + async def f(): + await some.complicated[0].call(with_args=(True or (1 is not 1))) +-print(* [] or [1]) ++ ++ ++print(*[] or [1]) + print(**{1: 3} if False else {x: x for x in range(3)}) +-print(* lambda x: x) +-assert(not Test),("Short message") +-assert this is ComplexTest and not requirements.fit_in_a_single_line(force=False), "Short message" +-assert(((parens is TooMany))) +-for x, in (1,), (2,), (3,): ... +-for y in (): ... +-for z in (i for i in (1, 2, 3)): ... +-for i in (call()): ... +-for j in (1 + (2 + 3)): ... +-while(this and that): ... +-for addr_family, addr_type, addr_proto, addr_canonname, addr_sockaddr in socket.getaddrinfo('google.com', 'http'): ++print(*lambda x: x) ++assert not Test, "Short message" ++assert this is ComplexTest and not requirements.fit_in_a_single_line( ++ force=False ++), "Short message" ++assert parens is TooMany ++for (x,) in (1,), (2,), (3,): ++ ... ++for y in (): ++ ... ++for z in (i for i in (1, 2, 3)): ++ ... ++for i in call(): ++ ... ++for j in 1 + (2 + 3): ++ ... ++while this and that: ++ ... ++for ( ++ addr_family, ++ addr_type, ++ addr_proto, ++ addr_canonname, ++ addr_sockaddr, ++) in socket.getaddrinfo("google.com", "http"): + pass +-a = aaaa.bbbb.cccc.dddd.eeee.ffff.gggg.hhhh.iiii.jjjj.kkkk.llll.mmmm.nnnn.oooo.pppp in qqqq.rrrr.ssss.tttt.uuuu.vvvv.xxxx.yyyy.zzzz +-a = aaaa.bbbb.cccc.dddd.eeee.ffff.gggg.hhhh.iiii.jjjj.kkkk.llll.mmmm.nnnn.oooo.pppp not in qqqq.rrrr.ssss.tttt.uuuu.vvvv.xxxx.yyyy.zzzz +-a = aaaa.bbbb.cccc.dddd.eeee.ffff.gggg.hhhh.iiii.jjjj.kkkk.llll.mmmm.nnnn.oooo.pppp is qqqq.rrrr.ssss.tttt.uuuu.vvvv.xxxx.yyyy.zzzz +-a = aaaa.bbbb.cccc.dddd.eeee.ffff.gggg.hhhh.iiii.jjjj.kkkk.llll.mmmm.nnnn.oooo.pppp is not qqqq.rrrr.ssss.tttt.uuuu.vvvv.xxxx.yyyy.zzzz +-if ( +- threading.current_thread() != threading.main_thread() and +- threading.current_thread() != threading.main_thread() or +- signal.getsignal(signal.SIGINT) != signal.default_int_handler +-): +- return True +-if ( +- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa | +- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +-): +- return True +-if ( +- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa & +- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +-): +- return True +-if ( +- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + +- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +-): +- return True +-if ( +- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa - +- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +-): +- return True +-if ( +- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * +- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +-): +- return True +-if ( +- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa / +- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +-): +- return True +-if ( +- ~ aaaa.a + aaaa.b - aaaa.c * aaaa.d / aaaa.e | aaaa.f & aaaa.g % aaaa.h ^ aaaa.i << aaaa.k >> aaaa.l ** aaaa.m // aaaa.n +-): +- return True +-if ( +- ~ aaaaaaaa.a + aaaaaaaa.b - aaaaaaaa.c @ aaaaaaaa.d / aaaaaaaa.e | aaaaaaaa.f & aaaaaaaa.g % aaaaaaaa.h ^ aaaaaaaa.i << aaaaaaaa.k >> aaaaaaaa.l ** aaaaaaaa.m // aaaaaaaa.n +-): +- return True +-if ( +- ~ aaaaaaaaaaaaaaaa.a + aaaaaaaaaaaaaaaa.b - aaaaaaaaaaaaaaaa.c * aaaaaaaaaaaaaaaa.d @ aaaaaaaaaaaaaaaa.e | aaaaaaaaaaaaaaaa.f & aaaaaaaaaaaaaaaa.g % aaaaaaaaaaaaaaaa.h ^ aaaaaaaaaaaaaaaa.i << aaaaaaaaaaaaaaaa.k >> aaaaaaaaaaaaaaaa.l ** aaaaaaaaaaaaaaaa.m // aaaaaaaaaaaaaaaa.n +-): +- return True +-aaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaa - aaaaaaaaaaaaaaaa * (aaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaa) / (aaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaa) ++a = ( ++ aaaa.bbbb.cccc.dddd.eeee.ffff.gggg.hhhh.iiii.jjjj.kkkk.llll.mmmm.nnnn.oooo.pppp ++ in qqqq.rrrr.ssss.tttt.uuuu.vvvv.xxxx.yyyy.zzzz ++) ++a = ( ++ aaaa.bbbb.cccc.dddd.eeee.ffff.gggg.hhhh.iiii.jjjj.kkkk.llll.mmmm.nnnn.oooo.pppp ++ not in qqqq.rrrr.ssss.tttt.uuuu.vvvv.xxxx.yyyy.zzzz ++) ++a = ( ++ aaaa.bbbb.cccc.dddd.eeee.ffff.gggg.hhhh.iiii.jjjj.kkkk.llll.mmmm.nnnn.oooo.pppp ++ is qqqq.rrrr.ssss.tttt.uuuu.vvvv.xxxx.yyyy.zzzz ++) ++a = ( ++ aaaa.bbbb.cccc.dddd.eeee.ffff.gggg.hhhh.iiii.jjjj.kkkk.llll.mmmm.nnnn.oooo.pppp ++ is not qqqq.rrrr.ssss.tttt.uuuu.vvvv.xxxx.yyyy.zzzz ++) ++if ( ++ threading.current_thread() != threading.main_thread() ++ and threading.current_thread() != threading.main_thread() ++ or signal.getsignal(signal.SIGINT) != signal.default_int_handler ++): ++ return True ++if ( ++ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++ | aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++): ++ return True ++if ( ++ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++ & aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++): ++ return True ++if ( ++ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++ + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++): ++ return True ++if ( ++ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++ - aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++): ++ return True ++if ( ++ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++ * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++): ++ return True ++if ( ++ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++ / aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++): ++ return True ++if ( ++ ~aaaa.a + aaaa.b - aaaa.c * aaaa.d / aaaa.e ++ | aaaa.f & aaaa.g % aaaa.h ^ aaaa.i << aaaa.k >> aaaa.l**aaaa.m // aaaa.n ++): ++ return True ++if ( ++ ~aaaaaaaa.a + aaaaaaaa.b - aaaaaaaa.c @ aaaaaaaa.d / aaaaaaaa.e ++ | aaaaaaaa.f & aaaaaaaa.g % aaaaaaaa.h ++ ^ aaaaaaaa.i << aaaaaaaa.k >> aaaaaaaa.l**aaaaaaaa.m // aaaaaaaa.n ++): ++ return True ++if ( ++ ~aaaaaaaaaaaaaaaa.a ++ + aaaaaaaaaaaaaaaa.b ++ - aaaaaaaaaaaaaaaa.c * aaaaaaaaaaaaaaaa.d @ aaaaaaaaaaaaaaaa.e ++ | aaaaaaaaaaaaaaaa.f & aaaaaaaaaaaaaaaa.g % aaaaaaaaaaaaaaaa.h ++ ^ aaaaaaaaaaaaaaaa.i ++ << aaaaaaaaaaaaaaaa.k ++ >> aaaaaaaaaaaaaaaa.l**aaaaaaaaaaaaaaaa.m // aaaaaaaaaaaaaaaa.n ++): ++ return True ++( ++ aaaaaaaaaaaaaaaa ++ + aaaaaaaaaaaaaaaa ++ - aaaaaaaaaaaaaaaa ++ * (aaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaa) ++ / (aaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaa) ++) + aaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaa +-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++( ++ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++ >> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++ << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++) + bbbb >> bbbb * bbbb +-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ^bbbb.a & aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++( ++ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++ ^ bbbb.a & aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++ ^ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++) + last_call() + # standalone comment at ENDMARKER diff --git a/tests/data/cases/expression.py b/tests/data/cases/expression.py new file mode 100644 index 0000000..06096c5 --- /dev/null +++ b/tests/data/cases/expression.py @@ -0,0 +1,630 @@ +... +'some_string' +b'\\xa3' +Name +None +True +False +1 +1.0 +1j +True or False +True or False or None +True and False +True and False and None +(Name1 and Name2) or Name3 +Name1 and Name2 or Name3 +Name1 or (Name2 and Name3) +Name1 or Name2 and Name3 +(Name1 and Name2) or (Name3 and Name4) +Name1 and Name2 or Name3 and Name4 +Name1 or (Name2 and Name3) or Name4 +Name1 or Name2 and Name3 or Name4 +v1 << 2 +1 >> v2 +1 % finished +1 + v2 - v3 * 4 ^ 5 ** v6 / 7 // 8 +((1 + v2) - (v3 * 4)) ^ (((5 ** v6) / 7) // 8) +not great +~great ++value +-1 +~int and not v1 ^ 123 + v2 | True +(~int) and (not ((v1 ^ (123 + v2)) | True)) ++really ** -confusing ** ~operator ** -precedence +flags & ~ select.EPOLLIN and waiters.write_task is not None +lambda arg: None +lambda a=True: a +lambda a, b, c=True: a +lambda a, b, c=True, *, d=(1 << v2), e='str': a +lambda a, b, c=True, *vararg, d=(v1 << 2), e='str', **kwargs: a + b +manylambdas = lambda x=lambda y=lambda z=1: z: y(): x() +foo = (lambda port_id, ignore_missing: {"port1": port1_resource, "port2": port2_resource}[port_id]) +1 if True else 2 +str or None if True else str or bytes or None +(str or None) if True else (str or bytes or None) +str or None if (1 if True else 2) else str or bytes or None +(str or None) if (1 if True else 2) else (str or bytes or None) +((super_long_variable_name or None) if (1 if super_long_test_name else 2) else (str or bytes or None)) +{'2.7': dead, '3.7': (long_live or die_hard)} +{'2.7': dead, '3.7': (long_live or die_hard), **{'3.6': verygood}} +{**a, **b, **c} +{'2.7', '3.6', '3.7', '3.8', '3.9', ('4.0' if gilectomy else '3.10')} +({'a': 'b'}, (True or False), (+value), 'string', b'bytes') or None +() +(1,) +(1, 2) +(1, 2, 3) +[] +[1, 2, 3, 4, 5, 6, 7, 8, 9, (10 or A), (11 or B), (12 or C)] +[1, 2, 3,] +[*a] +[*range(10)] +[*a, 4, 5,] +[4, *a, 5,] +[this_is_a_very_long_variable_which_will_force_a_delimiter_split, element, another, *more] +{i for i in (1, 2, 3)} +{(i ** 2) for i in (1, 2, 3)} +{(i ** 2) for i, _ in ((1, 'a'), (2, 'b'), (3, 'c'))} +{((i ** 2) + j) for i in (1, 2, 3) for j in (1, 2, 3)} +[i for i in (1, 2, 3)] +[(i ** 2) for i in (1, 2, 3)] +[(i ** 2) for i, _ in ((1, 'a'), (2, 'b'), (3, 'c'))] +[((i ** 2) + j) for i in (1, 2, 3) for j in (1, 2, 3)] +{i: 0 for i in (1, 2, 3)} +{i: j for i, j in ((1, 'a'), (2, 'b'), (3, 'c'))} +{a: b * 2 for a, b in dictionary.items()} +{a: b * -2 for a, b in dictionary.items()} +{k: v for k, v in this_is_a_very_long_variable_which_will_cause_a_trailing_comma_which_breaks_the_comprehension} +Python3 > Python2 > COBOL +Life is Life +call() +call(arg) +call(kwarg='hey') +call(arg, kwarg='hey') +call(arg, another, kwarg='hey', **kwargs) +call(this_is_a_very_long_variable_which_will_force_a_delimiter_split, arg, another, kwarg='hey', **kwargs) # note: no trailing comma pre-3.6 +call(*gidgets[:2]) +call(a, *gidgets[:2]) +call(**self.screen_kwargs) +call(b, **self.screen_kwargs) +lukasz.langa.pl +call.me(maybe) +1 .real +1.0 .real +....__class__ +list[str] +dict[str, int] +tuple[str, ...] +tuple[ + str, int, float, dict[str, int] +] +tuple[str, int, float, dict[str, int],] +very_long_variable_name_filters: t.List[ + t.Tuple[str, t.Union[str, t.List[t.Optional[str]]]], +] +xxxx_xxxxx_xxxx_xxx: Callable[..., List[SomeClass]] = classmethod( # type: ignore + sync(async_xxxx_xxx_xxxx_xxxxx_xxxx_xxx.__func__) +) +xxxx_xxx_xxxx_xxxxx_xxxx_xxx: Callable[..., List[SomeClass]] = classmethod( # type: ignore + sync(async_xxxx_xxx_xxxx_xxxxx_xxxx_xxx.__func__) +) +xxxx_xxx_xxxx_xxxxx_xxxx_xxx: Callable[ + ..., List[SomeClass] +] = classmethod(sync(async_xxxx_xxx_xxxx_xxxxx_xxxx_xxx.__func__)) # type: ignore +slice[0] +slice[0:1] +slice[0:1:2] +slice[:] +slice[:-1] +slice[1:] +slice[::-1] +slice[d :: d + 1] +slice[:c, c - 1] +numpy[:, 0:1] +numpy[:, :-1] +numpy[0, :] +numpy[:, i] +numpy[0, :2] +numpy[:N, 0] +numpy[:2, :4] +numpy[2:4, 1:5] +numpy[4:, 2:] +numpy[:, (0, 1, 2, 5)] +numpy[0, [0]] +numpy[:, [i]] +numpy[1 : c + 1, c] +numpy[-(c + 1) :, d] +numpy[:, l[-2]] +numpy[:, ::-1] +numpy[np.newaxis, :] +(str or None) if (sys.version_info[0] > (3,)) else (str or bytes or None) +{'2.7': dead, '3.7': long_live or die_hard} +{'2.7', '3.6', '3.7', '3.8', '3.9', '4.0' if gilectomy else '3.10'} +[1, 2, 3, 4, 5, 6, 7, 8, 9, 10 or A, 11 or B, 12 or C] +(SomeName) +SomeName +(Good, Bad, Ugly) +(i for i in (1, 2, 3)) +((i ** 2) for i in (1, 2, 3)) +((i ** 2) for i, _ in ((1, 'a'), (2, 'b'), (3, 'c'))) +(((i ** 2) + j) for i in (1, 2, 3) for j in (1, 2, 3)) +(*starred,) +{"id": "1","type": "type","started_at": now(),"ended_at": now() + timedelta(days=10),"priority": 1,"import_session_id": 1,**kwargs} +a = (1,) +b = 1, +c = 1 +d = (1,) + a + (2,) +e = (1,).count(1) +f = 1, *range(10) +g = 1, *"ten" +what_is_up_with_those_new_coord_names = (coord_names + set(vars_to_create)) + set(vars_to_remove) +what_is_up_with_those_new_coord_names = (coord_names | set(vars_to_create)) - set(vars_to_remove) +result = session.query(models.Customer.id).filter(models.Customer.account_id == account_id, models.Customer.email == email_address).order_by(models.Customer.id.asc()).all() +result = session.query(models.Customer.id).filter(models.Customer.account_id == account_id, models.Customer.email == email_address).order_by(models.Customer.id.asc(),).all() +Ø = set() +authors.łukasz.say_thanks() +mapping = { + A: 0.25 * (10.0 / 12), + B: 0.1 * (10.0 / 12), + C: 0.1 * (10.0 / 12), + D: 0.1 * (10.0 / 12), +} + +def gen(): + yield from outside_of_generator + a = (yield) + b = ((yield)) + c = (((yield))) + +async def f(): + await some.complicated[0].call(with_args=(True or (1 is not 1))) +print(* [] or [1]) +print(**{1: 3} if False else {x: x for x in range(3)}) +print(* lambda x: x) +assert(not Test),("Short message") +assert this is ComplexTest and not requirements.fit_in_a_single_line(force=False), "Short message" +assert(((parens is TooMany))) +for x, in (1,), (2,), (3,): ... +for y in (): ... +for z in (i for i in (1, 2, 3)): ... +for i in (call()): ... +for j in (1 + (2 + 3)): ... +while(this and that): ... +for addr_family, addr_type, addr_proto, addr_canonname, addr_sockaddr in socket.getaddrinfo('google.com', 'http'): + pass +a = aaaa.bbbb.cccc.dddd.eeee.ffff.gggg.hhhh.iiii.jjjj.kkkk.llll.mmmm.nnnn.oooo.pppp in qqqq.rrrr.ssss.tttt.uuuu.vvvv.xxxx.yyyy.zzzz +a = aaaa.bbbb.cccc.dddd.eeee.ffff.gggg.hhhh.iiii.jjjj.kkkk.llll.mmmm.nnnn.oooo.pppp not in qqqq.rrrr.ssss.tttt.uuuu.vvvv.xxxx.yyyy.zzzz +a = aaaa.bbbb.cccc.dddd.eeee.ffff.gggg.hhhh.iiii.jjjj.kkkk.llll.mmmm.nnnn.oooo.pppp is qqqq.rrrr.ssss.tttt.uuuu.vvvv.xxxx.yyyy.zzzz +a = aaaa.bbbb.cccc.dddd.eeee.ffff.gggg.hhhh.iiii.jjjj.kkkk.llll.mmmm.nnnn.oooo.pppp is not qqqq.rrrr.ssss.tttt.uuuu.vvvv.xxxx.yyyy.zzzz +if ( + threading.current_thread() != threading.main_thread() and + threading.current_thread() != threading.main_thread() or + signal.getsignal(signal.SIGINT) != signal.default_int_handler +): + return True +if ( + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa | + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +): + return True +if ( + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa & + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +): + return True +if ( + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +): + return True +if ( + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa - + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +): + return True +if ( + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +): + return True +if ( + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa / + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +): + return True +if ( + ~ aaaa.a + aaaa.b - aaaa.c * aaaa.d / aaaa.e | aaaa.f & aaaa.g % aaaa.h ^ aaaa.i << aaaa.k >> aaaa.l ** aaaa.m // aaaa.n +): + return True +if ( + ~ aaaaaaaa.a + aaaaaaaa.b - aaaaaaaa.c @ aaaaaaaa.d / aaaaaaaa.e | aaaaaaaa.f & aaaaaaaa.g % aaaaaaaa.h ^ aaaaaaaa.i << aaaaaaaa.k >> aaaaaaaa.l ** aaaaaaaa.m // aaaaaaaa.n +): + return True +if ( + ~ aaaaaaaaaaaaaaaa.a + aaaaaaaaaaaaaaaa.b - aaaaaaaaaaaaaaaa.c * aaaaaaaaaaaaaaaa.d @ aaaaaaaaaaaaaaaa.e | aaaaaaaaaaaaaaaa.f & aaaaaaaaaaaaaaaa.g % aaaaaaaaaaaaaaaa.h ^ aaaaaaaaaaaaaaaa.i << aaaaaaaaaaaaaaaa.k >> aaaaaaaaaaaaaaaa.l ** aaaaaaaaaaaaaaaa.m // aaaaaaaaaaaaaaaa.n +): + return True +aaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaa - aaaaaaaaaaaaaaaa * (aaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaa) / (aaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaa) +aaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaa +aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +bbbb >> bbbb * bbbb +aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ^bbbb.a & aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +last_call() +# standalone comment at ENDMARKER + + +# output + + +... +"some_string" +b"\\xa3" +Name +None +True +False +1 +1.0 +1j +True or False +True or False or None +True and False +True and False and None +(Name1 and Name2) or Name3 +Name1 and Name2 or Name3 +Name1 or (Name2 and Name3) +Name1 or Name2 and Name3 +(Name1 and Name2) or (Name3 and Name4) +Name1 and Name2 or Name3 and Name4 +Name1 or (Name2 and Name3) or Name4 +Name1 or Name2 and Name3 or Name4 +v1 << 2 +1 >> v2 +1 % finished +1 + v2 - v3 * 4 ^ 5**v6 / 7 // 8 +((1 + v2) - (v3 * 4)) ^ (((5**v6) / 7) // 8) +not great +~great ++value +-1 +~int and not v1 ^ 123 + v2 | True +(~int) and (not ((v1 ^ (123 + v2)) | True)) ++(really ** -(confusing ** ~(operator**-precedence))) +flags & ~select.EPOLLIN and waiters.write_task is not None +lambda arg: None +lambda a=True: a +lambda a, b, c=True: a +lambda a, b, c=True, *, d=(1 << v2), e="str": a +lambda a, b, c=True, *vararg, d=(v1 << 2), e="str", **kwargs: a + b +manylambdas = lambda x=lambda y=lambda z=1: z: y(): x() +foo = lambda port_id, ignore_missing: { + "port1": port1_resource, + "port2": port2_resource, +}[port_id] +1 if True else 2 +str or None if True else str or bytes or None +(str or None) if True else (str or bytes or None) +str or None if (1 if True else 2) else str or bytes or None +(str or None) if (1 if True else 2) else (str or bytes or None) +( + (super_long_variable_name or None) + if (1 if super_long_test_name else 2) + else (str or bytes or None) +) +{"2.7": dead, "3.7": (long_live or die_hard)} +{"2.7": dead, "3.7": (long_live or die_hard), **{"3.6": verygood}} +{**a, **b, **c} +{"2.7", "3.6", "3.7", "3.8", "3.9", ("4.0" if gilectomy else "3.10")} +({"a": "b"}, (True or False), (+value), "string", b"bytes") or None +() +(1,) +(1, 2) +(1, 2, 3) +[] +[1, 2, 3, 4, 5, 6, 7, 8, 9, (10 or A), (11 or B), (12 or C)] +[ + 1, + 2, + 3, +] +[*a] +[*range(10)] +[ + *a, + 4, + 5, +] +[ + 4, + *a, + 5, +] +[ + this_is_a_very_long_variable_which_will_force_a_delimiter_split, + element, + another, + *more, +] +{i for i in (1, 2, 3)} +{(i**2) for i in (1, 2, 3)} +{(i**2) for i, _ in ((1, "a"), (2, "b"), (3, "c"))} +{((i**2) + j) for i in (1, 2, 3) for j in (1, 2, 3)} +[i for i in (1, 2, 3)] +[(i**2) for i in (1, 2, 3)] +[(i**2) for i, _ in ((1, "a"), (2, "b"), (3, "c"))] +[((i**2) + j) for i in (1, 2, 3) for j in (1, 2, 3)] +{i: 0 for i in (1, 2, 3)} +{i: j for i, j in ((1, "a"), (2, "b"), (3, "c"))} +{a: b * 2 for a, b in dictionary.items()} +{a: b * -2 for a, b in dictionary.items()} +{ + k: v + for k, v in this_is_a_very_long_variable_which_will_cause_a_trailing_comma_which_breaks_the_comprehension +} +Python3 > Python2 > COBOL +Life is Life +call() +call(arg) +call(kwarg="hey") +call(arg, kwarg="hey") +call(arg, another, kwarg="hey", **kwargs) +call( + this_is_a_very_long_variable_which_will_force_a_delimiter_split, + arg, + another, + kwarg="hey", + **kwargs +) # note: no trailing comma pre-3.6 +call(*gidgets[:2]) +call(a, *gidgets[:2]) +call(**self.screen_kwargs) +call(b, **self.screen_kwargs) +lukasz.langa.pl +call.me(maybe) +(1).real +(1.0).real +....__class__ +list[str] +dict[str, int] +tuple[str, ...] +tuple[str, int, float, dict[str, int]] +tuple[ + str, + int, + float, + dict[str, int], +] +very_long_variable_name_filters: t.List[ + t.Tuple[str, t.Union[str, t.List[t.Optional[str]]]], +] +xxxx_xxxxx_xxxx_xxx: Callable[..., List[SomeClass]] = classmethod( # type: ignore + sync(async_xxxx_xxx_xxxx_xxxxx_xxxx_xxx.__func__) +) +xxxx_xxx_xxxx_xxxxx_xxxx_xxx: Callable[..., List[SomeClass]] = classmethod( # type: ignore + sync(async_xxxx_xxx_xxxx_xxxxx_xxxx_xxx.__func__) +) +xxxx_xxx_xxxx_xxxxx_xxxx_xxx: Callable[..., List[SomeClass]] = classmethod( + sync(async_xxxx_xxx_xxxx_xxxxx_xxxx_xxx.__func__) +) # type: ignore +slice[0] +slice[0:1] +slice[0:1:2] +slice[:] +slice[:-1] +slice[1:] +slice[::-1] +slice[d :: d + 1] +slice[:c, c - 1] +numpy[:, 0:1] +numpy[:, :-1] +numpy[0, :] +numpy[:, i] +numpy[0, :2] +numpy[:N, 0] +numpy[:2, :4] +numpy[2:4, 1:5] +numpy[4:, 2:] +numpy[:, (0, 1, 2, 5)] +numpy[0, [0]] +numpy[:, [i]] +numpy[1 : c + 1, c] +numpy[-(c + 1) :, d] +numpy[:, l[-2]] +numpy[:, ::-1] +numpy[np.newaxis, :] +(str or None) if (sys.version_info[0] > (3,)) else (str or bytes or None) +{"2.7": dead, "3.7": long_live or die_hard} +{"2.7", "3.6", "3.7", "3.8", "3.9", "4.0" if gilectomy else "3.10"} +[1, 2, 3, 4, 5, 6, 7, 8, 9, 10 or A, 11 or B, 12 or C] +(SomeName) +SomeName +(Good, Bad, Ugly) +(i for i in (1, 2, 3)) +((i**2) for i in (1, 2, 3)) +((i**2) for i, _ in ((1, "a"), (2, "b"), (3, "c"))) +(((i**2) + j) for i in (1, 2, 3) for j in (1, 2, 3)) +(*starred,) +{ + "id": "1", + "type": "type", + "started_at": now(), + "ended_at": now() + timedelta(days=10), + "priority": 1, + "import_session_id": 1, + **kwargs, +} +a = (1,) +b = (1,) +c = 1 +d = (1,) + a + (2,) +e = (1,).count(1) +f = 1, *range(10) +g = 1, *"ten" +what_is_up_with_those_new_coord_names = (coord_names + set(vars_to_create)) + set( + vars_to_remove +) +what_is_up_with_those_new_coord_names = (coord_names | set(vars_to_create)) - set( + vars_to_remove +) +result = ( + session.query(models.Customer.id) + .filter( + models.Customer.account_id == account_id, models.Customer.email == email_address + ) + .order_by(models.Customer.id.asc()) + .all() +) +result = ( + session.query(models.Customer.id) + .filter( + models.Customer.account_id == account_id, models.Customer.email == email_address + ) + .order_by( + models.Customer.id.asc(), + ) + .all() +) +Ø = set() +authors.łukasz.say_thanks() +mapping = { + A: 0.25 * (10.0 / 12), + B: 0.1 * (10.0 / 12), + C: 0.1 * (10.0 / 12), + D: 0.1 * (10.0 / 12), +} + + +def gen(): + yield from outside_of_generator + a = yield + b = yield + c = yield + + +async def f(): + await some.complicated[0].call(with_args=(True or (1 is not 1))) + + +print(*[] or [1]) +print(**{1: 3} if False else {x: x for x in range(3)}) +print(*lambda x: x) +assert not Test, "Short message" +assert this is ComplexTest and not requirements.fit_in_a_single_line( + force=False +), "Short message" +assert parens is TooMany +for (x,) in (1,), (2,), (3,): + ... +for y in (): + ... +for z in (i for i in (1, 2, 3)): + ... +for i in call(): + ... +for j in 1 + (2 + 3): + ... +while this and that: + ... +for ( + addr_family, + addr_type, + addr_proto, + addr_canonname, + addr_sockaddr, +) in socket.getaddrinfo("google.com", "http"): + pass +a = ( + aaaa.bbbb.cccc.dddd.eeee.ffff.gggg.hhhh.iiii.jjjj.kkkk.llll.mmmm.nnnn.oooo.pppp + in qqqq.rrrr.ssss.tttt.uuuu.vvvv.xxxx.yyyy.zzzz +) +a = ( + aaaa.bbbb.cccc.dddd.eeee.ffff.gggg.hhhh.iiii.jjjj.kkkk.llll.mmmm.nnnn.oooo.pppp + not in qqqq.rrrr.ssss.tttt.uuuu.vvvv.xxxx.yyyy.zzzz +) +a = ( + aaaa.bbbb.cccc.dddd.eeee.ffff.gggg.hhhh.iiii.jjjj.kkkk.llll.mmmm.nnnn.oooo.pppp + is qqqq.rrrr.ssss.tttt.uuuu.vvvv.xxxx.yyyy.zzzz +) +a = ( + aaaa.bbbb.cccc.dddd.eeee.ffff.gggg.hhhh.iiii.jjjj.kkkk.llll.mmmm.nnnn.oooo.pppp + is not qqqq.rrrr.ssss.tttt.uuuu.vvvv.xxxx.yyyy.zzzz +) +if ( + threading.current_thread() != threading.main_thread() + and threading.current_thread() != threading.main_thread() + or signal.getsignal(signal.SIGINT) != signal.default_int_handler +): + return True +if ( + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + | aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +): + return True +if ( + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + & aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +): + return True +if ( + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +): + return True +if ( + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + - aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +): + return True +if ( + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +): + return True +if ( + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + / aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +): + return True +if ( + ~aaaa.a + aaaa.b - aaaa.c * aaaa.d / aaaa.e + | aaaa.f & aaaa.g % aaaa.h ^ aaaa.i << aaaa.k >> aaaa.l**aaaa.m // aaaa.n +): + return True +if ( + ~aaaaaaaa.a + aaaaaaaa.b - aaaaaaaa.c @ aaaaaaaa.d / aaaaaaaa.e + | aaaaaaaa.f & aaaaaaaa.g % aaaaaaaa.h + ^ aaaaaaaa.i << aaaaaaaa.k >> aaaaaaaa.l**aaaaaaaa.m // aaaaaaaa.n +): + return True +if ( + ~aaaaaaaaaaaaaaaa.a + + aaaaaaaaaaaaaaaa.b + - aaaaaaaaaaaaaaaa.c * aaaaaaaaaaaaaaaa.d @ aaaaaaaaaaaaaaaa.e + | aaaaaaaaaaaaaaaa.f & aaaaaaaaaaaaaaaa.g % aaaaaaaaaaaaaaaa.h + ^ aaaaaaaaaaaaaaaa.i + << aaaaaaaaaaaaaaaa.k + >> aaaaaaaaaaaaaaaa.l**aaaaaaaaaaaaaaaa.m // aaaaaaaaaaaaaaaa.n +): + return True +( + aaaaaaaaaaaaaaaa + + aaaaaaaaaaaaaaaa + - aaaaaaaaaaaaaaaa + * (aaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaa) + / (aaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaa) +) +aaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaa +( + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + >> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +) +bbbb >> bbbb * bbbb +( + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + ^ bbbb.a & aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + ^ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +) +last_call() +# standalone comment at ENDMARKER diff --git a/tests/data/cases/f_docstring.py b/tests/data/cases/f_docstring.py new file mode 100644 index 0000000..667f550 --- /dev/null +++ b/tests/data/cases/f_docstring.py @@ -0,0 +1,20 @@ +def foo(e): + f""" {'.'.join(e)}""" + +def bar(e): + f"{'.'.join(e)}" + +def baz(e): + F""" {'.'.join(e)}""" + +# output +def foo(e): + f""" {'.'.join(e)}""" + + +def bar(e): + f"{'.'.join(e)}" + + +def baz(e): + f""" {'.'.join(e)}""" diff --git a/tests/data/cases/fmtonoff.py b/tests/data/cases/fmtonoff.py new file mode 100644 index 0000000..56d99b8 --- /dev/null +++ b/tests/data/cases/fmtonoff.py @@ -0,0 +1,521 @@ +#!/usr/bin/env python3 +import asyncio +import sys + +from third_party import X, Y, Z + +from library import some_connection, \ + some_decorator +# fmt: off +from third_party import (X, + Y, Z) +# fmt: on +f'trigger 3.6 mode' +# Comment 1 + +# Comment 2 + +# fmt: off +def func_no_args(): + a; b; c + if True: raise RuntimeError + if False: ... + for i in range(10): + print(i) + continue + exec('new-style exec', {}, {}) + return None +async def coroutine(arg, exec=False): + 'Single-line docstring. Multiline is harder to reformat.' + async with some_connection() as conn: + await conn.do_what_i_mean('SELECT bobby, tables FROM xkcd', timeout=2) + await asyncio.sleep(1) +@asyncio.coroutine +@some_decorator( +with_args=True, +many_args=[1,2,3] +) +def function_signature_stress_test(number:int,no_annotation=None,text:str='default',* ,debug:bool=False,**kwargs) -> str: + return text[number:-1] +# fmt: on +def spaces(a=1, b=(), c=[], d={}, e=True, f=-1, g=1 if False else 2, h="", i=r''): + offset = attr.ib(default=attr.Factory( lambda: _r.uniform(1, 2))) + assert task._cancel_stack[:len(old_stack)] == old_stack +def spaces_types(a: int = 1, b: tuple = (), c: list = [], d: dict = {}, e: bool = True, f: int = -1, g: int = 1 if False else 2, h: str = "", i: str = r''): ... +def spaces2(result= _core.Value(None)): + ... +something = { + # fmt: off + key: 'value', +} + +def subscriptlist(): + atom[ + # fmt: off + 'some big and', + 'complex subscript', + # fmt: on + goes + here, andhere, + ] + +def import_as_names(): + # fmt: off + from hello import a, b + 'unformatted' + # fmt: on + +def testlist_star_expr(): + # fmt: off + a , b = *hello + 'unformatted' + # fmt: on + +def yield_expr(): + # fmt: off + yield hello + 'unformatted' + # fmt: on + 'formatted' + # fmt: off + ( yield hello ) + 'unformatted' + # fmt: on + +def example(session): + # fmt: off + result = session\ + .query(models.Customer.id)\ + .filter(models.Customer.account_id == account_id, + models.Customer.email == email_address)\ + .order_by(models.Customer.id.asc())\ + .all() + # fmt: on +def off_and_on_without_data(): + """Test that comment-only fmt:off/on blocks preserve formatting.""" + # fmt: off + #should not be formatted + # fmt: on + # fmt: off + + #should not be formatted + + # fmt: on + # fmt: off + #should not be formatted + #should not be formatted #also should not be formatted + # fmt: on + pass +def on_and_off_with_comment_only_blocks(): + """Test that fmt:off/on works with multiple directives and comment-only blocks.""" + # fmt: on + # fmt: off + this=should.not_be.formatted() + and_=indeed . it is not formatted + because . the . handling . inside . generate_ignored_nodes() + now . considers . multiple . fmt . directives . within . one . prefix + # fmt: on + # fmt: off + #should not be formatted + # fmt: on + # fmt: off + + #should not be formatted + + # fmt: on + # fmt: off + #should not be formatted + #should not be formatted #also should not be formatted + # fmt: on +def long_lines(): + if True: + typedargslist.extend( + gen_annotated_params(ast_args.kwonlyargs, ast_args.kw_defaults, parameters, implicit_default=True) + ) + # fmt: off + a = ( + unnecessary_bracket() + ) + # fmt: on + _type_comment_re = re.compile( + r""" + ^ + [\t ]* + \#[ ]type:[ ]* + (?P + [^#\t\n]+? + ) + (? to match + # a trailing space which is why we need the silliness below + (? + (?:\#[^\n]*)? + \n? + ) + $ + """, + # fmt: off + re.MULTILINE|re.VERBOSE + # fmt: on + ) +def single_literal_yapf_disable(): + """Black does not support this.""" + BAZ = { + (1, 2, 3, 4), + (5, 6, 7, 8), + (9, 10, 11, 12) + } # yapf: disable +cfg.rule( + "Default", "address", + xxxx_xxxx=["xxx-xxxxxx-xxxxxxxxxx"], + xxxxxx="xx_xxxxx", xxxxxxx="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", + xxxxxxxxx_xxxx=True, xxxxxxxx_xxxxxxxxxx=False, + xxxxxx_xxxxxx=2, xxxxxx_xxxxx_xxxxxxxx=70, xxxxxx_xxxxxx_xxxxx=True, + # fmt: off + xxxxxxx_xxxxxxxxxxxx={ + "xxxxxxxx": { + "xxxxxx": False, + "xxxxxxx": False, + "xxxx_xxxxxx": "xxxxx", + }, + "xxxxxxxx-xxxxx": { + "xxxxxx": False, + "xxxxxxx": True, + "xxxx_xxxxxx": "xxxxxx", + }, + }, + # fmt: on + xxxxxxxxxx_xxxxxxxxxxx_xxxxxxx_xxxxxxxxx=5 +) + +# Test comment-only blocks at file level with various spacing patterns +# fmt: off + #nospace + # twospaces +# fmt: on + + +# fmt: off +#nospaceatall + #extraspaces + #evenmorespaces +# fmt: on + + +# fmt: off +# fmt: on + + +# fmt: off +#SBATCH --job-name=test +#SBATCH --output=test.out +# fmt: on + + +# fmt: off + #first + + #second +# fmt: on + + +# fmt: off + #!@#$%^&*() + #<=>+-*/ +# fmt: on + + +# fmt: off + #x=1+2 + #y = 3 + #z = 4 +# fmt: on + +# fmt: off +yield 'hello' +# No formatting to the end of the file +l=[1,2,3] +d={'a':1, + 'b':2} + +# output + + +#!/usr/bin/env python3 +import asyncio +import sys + +from third_party import X, Y, Z + +from library import some_connection, some_decorator +# fmt: off +from third_party import (X, + Y, Z) +# fmt: on +f"trigger 3.6 mode" +# Comment 1 + +# Comment 2 + + +# fmt: off +def func_no_args(): + a; b; c + if True: raise RuntimeError + if False: ... + for i in range(10): + print(i) + continue + exec('new-style exec', {}, {}) + return None +async def coroutine(arg, exec=False): + 'Single-line docstring. Multiline is harder to reformat.' + async with some_connection() as conn: + await conn.do_what_i_mean('SELECT bobby, tables FROM xkcd', timeout=2) + await asyncio.sleep(1) +@asyncio.coroutine +@some_decorator( +with_args=True, +many_args=[1,2,3] +) +def function_signature_stress_test(number:int,no_annotation=None,text:str='default',* ,debug:bool=False,**kwargs) -> str: + return text[number:-1] +# fmt: on +def spaces(a=1, b=(), c=[], d={}, e=True, f=-1, g=1 if False else 2, h="", i=r""): + offset = attr.ib(default=attr.Factory(lambda: _r.uniform(1, 2))) + assert task._cancel_stack[: len(old_stack)] == old_stack + + +def spaces_types( + a: int = 1, + b: tuple = (), + c: list = [], + d: dict = {}, + e: bool = True, + f: int = -1, + g: int = 1 if False else 2, + h: str = "", + i: str = r"", +): ... +def spaces2(result=_core.Value(None)): ... + + +something = { + # fmt: off + key: 'value', +} + + +def subscriptlist(): + atom[ + # fmt: off + 'some big and', + 'complex subscript', + # fmt: on + goes + here, + andhere, + ] + + +def import_as_names(): + # fmt: off + from hello import a, b + 'unformatted' + # fmt: on + + +def testlist_star_expr(): + # fmt: off + a , b = *hello + 'unformatted' + # fmt: on + + +def yield_expr(): + # fmt: off + yield hello + 'unformatted' + # fmt: on + "formatted" + # fmt: off + ( yield hello ) + 'unformatted' + # fmt: on + + +def example(session): + # fmt: off + result = session\ + .query(models.Customer.id)\ + .filter(models.Customer.account_id == account_id, + models.Customer.email == email_address)\ + .order_by(models.Customer.id.asc())\ + .all() + # fmt: on + + +def off_and_on_without_data(): + """Test that comment-only fmt:off/on blocks preserve formatting.""" + # fmt: off + #should not be formatted + # fmt: on + # fmt: off + + #should not be formatted + + # fmt: on + # fmt: off + #should not be formatted + #should not be formatted #also should not be formatted + # fmt: on + pass + + +def on_and_off_with_comment_only_blocks(): + """Test that fmt:off/on works with multiple directives and comment-only blocks.""" + # fmt: on + # fmt: off + this=should.not_be.formatted() + and_=indeed . it is not formatted + because . the . handling . inside . generate_ignored_nodes() + now . considers . multiple . fmt . directives . within . one . prefix + + # fmt: off + #should not be formatted + # fmt: on + # fmt: off + + #should not be formatted + + # fmt: on + # fmt: off + #should not be formatted + #should not be formatted #also should not be formatted + # fmt: on + + +def long_lines(): + if True: + typedargslist.extend( + gen_annotated_params( + ast_args.kwonlyargs, + ast_args.kw_defaults, + parameters, + implicit_default=True, + ) + ) + # fmt: off + a = ( + unnecessary_bracket() + ) + # fmt: on + _type_comment_re = re.compile( + r""" + ^ + [\t ]* + \#[ ]type:[ ]* + (?P + [^#\t\n]+? + ) + (? to match + # a trailing space which is why we need the silliness below + (? + (?:\#[^\n]*)? + \n? + ) + $ + """, + # fmt: off + re.MULTILINE|re.VERBOSE + # fmt: on + ) + + +def single_literal_yapf_disable(): + """Black does not support this.""" + BAZ = {(1, 2, 3, 4), (5, 6, 7, 8), (9, 10, 11, 12)} # yapf: disable + + +cfg.rule( + "Default", + "address", + xxxx_xxxx=["xxx-xxxxxx-xxxxxxxxxx"], + xxxxxx="xx_xxxxx", + xxxxxxx="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", + xxxxxxxxx_xxxx=True, + xxxxxxxx_xxxxxxxxxx=False, + xxxxxx_xxxxxx=2, + xxxxxx_xxxxx_xxxxxxxx=70, + xxxxxx_xxxxxx_xxxxx=True, + # fmt: off + xxxxxxx_xxxxxxxxxxxx={ + "xxxxxxxx": { + "xxxxxx": False, + "xxxxxxx": False, + "xxxx_xxxxxx": "xxxxx", + }, + "xxxxxxxx-xxxxx": { + "xxxxxx": False, + "xxxxxxx": True, + "xxxx_xxxxxx": "xxxxxx", + }, + }, + # fmt: on + xxxxxxxxxx_xxxxxxxxxxx_xxxxxxx_xxxxxxxxx=5, +) + +# Test comment-only blocks at file level with various spacing patterns +# fmt: off + #nospace + # twospaces +# fmt: on + + +# fmt: off +#nospaceatall + #extraspaces + #evenmorespaces +# fmt: on + + +# fmt: off +# fmt: on + + +# fmt: off +#SBATCH --job-name=test +#SBATCH --output=test.out +# fmt: on + + +# fmt: off + #first + + #second +# fmt: on + + +# fmt: off + #!@#$%^&*() + #<=>+-*/ +# fmt: on + + +# fmt: off + #x=1+2 + #y = 3 + #z = 4 +# fmt: on + +# fmt: off +yield 'hello' +# No formatting to the end of the file +l=[1,2,3] +d={'a':1, + 'b':2} diff --git a/tests/data/cases/fmtonoff2.py b/tests/data/cases/fmtonoff2.py new file mode 100644 index 0000000..e8657c7 --- /dev/null +++ b/tests/data/cases/fmtonoff2.py @@ -0,0 +1,40 @@ +import pytest + +TmSt = 1 +TmEx = 2 + +# fmt: off + +# Test data: +# Position, Volume, State, TmSt/TmEx/None, [call, [arg1...]] + +@pytest.mark.parametrize('test', [ + + # Test don't manage the volume + [ + ('stuff', 'in') + ], +]) +def test_fader(test): + pass + +def check_fader(test): + + pass + +def verify_fader(test): + # misaligned comment + pass + +def verify_fader(test): + """Hey, ho.""" + assert test.passed() + +def test_calculate_fades(): + calcs = [ + # one is zero/none + (0, 4, 0, 0, 10, 0, 0, 6, 10), + (None, 4, 0, 0, 10, 0, 0, 6, 10), + ] + +# fmt: on diff --git a/tests/data/cases/fmtonoff3.py b/tests/data/cases/fmtonoff3.py new file mode 100644 index 0000000..4e3b024 --- /dev/null +++ b/tests/data/cases/fmtonoff3.py @@ -0,0 +1,35 @@ +# fmt: off +x = [ + 1, 2, + 3, 4, +] +# fmt: on + +# fmt: off +x = [ + 1, 2, + 3, 4, +] +# fmt: on + +x = [ + 1, 2, 3, 4 +] + +# output + +# fmt: off +x = [ + 1, 2, + 3, 4, +] +# fmt: on + +# fmt: off +x = [ + 1, 2, + 3, 4, +] +# fmt: on + +x = [1, 2, 3, 4] diff --git a/tests/data/cases/fmtonoff4.py b/tests/data/cases/fmtonoff4.py new file mode 100644 index 0000000..4ca7079 --- /dev/null +++ b/tests/data/cases/fmtonoff4.py @@ -0,0 +1,36 @@ +# fmt: off +@test([ + 1, 2, + 3, 4, +]) +# fmt: on +def f(): pass + +@test([ + 1, 2, + 3, 4, +]) +def f(): pass + +# output + +# fmt: off +@test([ + 1, 2, + 3, 4, +]) +# fmt: on +def f(): + pass + + +@test( + [ + 1, + 2, + 3, + 4, + ] +) +def f(): + pass diff --git a/tests/data/cases/fmtonoff5.py b/tests/data/cases/fmtonoff5.py new file mode 100644 index 0000000..4c134a9 --- /dev/null +++ b/tests/data/cases/fmtonoff5.py @@ -0,0 +1,175 @@ +# Regression test for https://github.com/psf/black/issues/3129. +setup( + entry_points={ + # fmt: off + "console_scripts": [ + "foo-bar" + "=foo.bar.:main", + # fmt: on + ] # Includes an formatted indentation. + }, +) + + +# Regression test for https://github.com/psf/black/issues/2015. +run( + # fmt: off + [ + "ls", + "-la", + ] + # fmt: on + + path, + check=True, +) + + +# Regression test for https://github.com/psf/black/issues/3026. +def test_func(): + # yapf: disable + if unformatted( args ): + return True + # yapf: enable + elif b: + return True + + return False + + +# Regression test for https://github.com/psf/black/issues/2567. +if True: + # fmt: off + for _ in range( 1 ): + # fmt: on + print ( "This won't be formatted" ) + print ( "This won't be formatted either" ) +else: + print ( "This will be formatted" ) + + +# Regression test for https://github.com/psf/black/issues/3184. +class A: + async def call(param): + if param: + # fmt: off + if param[0:4] in ( + "ABCD", "EFGH" + ) : + # fmt: on + print ( "This won't be formatted" ) + + elif param[0:4] in ("ZZZZ",): + print ( "This won't be formatted either" ) + + print ( "This will be formatted" ) + + +# Regression test for https://github.com/psf/black/issues/2985. +class Named(t.Protocol): + # fmt: off + @property + def this_wont_be_formatted ( self ) -> str: ... + +class Factory(t.Protocol): + def this_will_be_formatted ( self, **kwargs ) -> Named: ... + # fmt: on + + +# Regression test for https://github.com/psf/black/issues/3436. +if x: + return x +# fmt: off +elif unformatted: +# fmt: on + will_be_formatted () + + +# output + + +# Regression test for https://github.com/psf/black/issues/3129. +setup( + entry_points={ + # fmt: off + "console_scripts": [ + "foo-bar" + "=foo.bar.:main", + # fmt: on + ] # Includes an formatted indentation. + }, +) + + +# Regression test for https://github.com/psf/black/issues/2015. +run( + # fmt: off + [ + "ls", + "-la", + ] + # fmt: on + + path, + check=True, +) + + +# Regression test for https://github.com/psf/black/issues/3026. +def test_func(): + # yapf: disable + if unformatted( args ): + return True + # yapf: enable + elif b: + return True + + return False + + +# Regression test for https://github.com/psf/black/issues/2567. +if True: + # fmt: off + for _ in range( 1 ): + # fmt: on + print ( "This won't be formatted" ) + print ( "This won't be formatted either" ) +else: + print("This will be formatted") + + +# Regression test for https://github.com/psf/black/issues/3184. +class A: + async def call(param): + if param: + # fmt: off + if param[0:4] in ( + "ABCD", "EFGH" + ) : + # fmt: on + print ( "This won't be formatted" ) + + elif param[0:4] in ("ZZZZ",): + print ( "This won't be formatted either" ) + + print("This will be formatted") + + +# Regression test for https://github.com/psf/black/issues/2985. +class Named(t.Protocol): + # fmt: off + @property + def this_wont_be_formatted ( self ) -> str: ... + + +class Factory(t.Protocol): + def this_will_be_formatted(self, **kwargs) -> Named: ... + + # fmt: on + + +# Regression test for https://github.com/psf/black/issues/3436. +if x: + return x +# fmt: off +elif unformatted: + # fmt: on + will_be_formatted() diff --git a/tests/data/cases/fmtonoff6.py b/tests/data/cases/fmtonoff6.py new file mode 100644 index 0000000..cab86ee --- /dev/null +++ b/tests/data/cases/fmtonoff6.py @@ -0,0 +1,89 @@ +# Regression test for https://github.com/psf/black/issues/2478. +def foo(): + arr = ( + (3833567325051000, 5, 1, 2, 4229.25, 6, 0), + # fmt: off + ) + + +# Regression test for https://github.com/psf/black/issues/3458. +dependencies = { + a: b, + # fmt: off +} + + +# Regression test for https://github.com/psf/black/issues/4511. +# fmt: off inside brackets with an f-string should not crash. +( + # fmt: off + f""" +""" + # fmt: on +) + +[ + # fmt: off + f"{x}" + # fmt: on +] + +# Same as above but unindented inside brackets. +( +# fmt: off +f""" +""" +# fmt: on +) + +[ +# fmt: off +f"{x}" +# fmt: on +] + +# output + +# Regression test for https://github.com/psf/black/issues/2478. +def foo(): + arr = ( + (3833567325051000, 5, 1, 2, 4229.25, 6, 0), + # fmt: off + ) + + +# Regression test for https://github.com/psf/black/issues/3458. +dependencies = { + a: b, + # fmt: off +} + + +# Regression test for https://github.com/psf/black/issues/4511. +# fmt: off inside brackets with an f-string should not crash. +( + # fmt: off + f""" +""" + # fmt: on +) + +[ + # fmt: off + f"{x}" + # fmt: on +] + +# Same as above but unindented inside brackets. +( + # fmt: off +f""" +""" + # fmt: on +) + +[ + # fmt: off +f"{x}" + # fmt: on +] diff --git a/tests/data/cases/fmtonoff_comment_only_with.py b/tests/data/cases/fmtonoff_comment_only_with.py new file mode 100644 index 0000000..ab69889 --- /dev/null +++ b/tests/data/cases/fmtonoff_comment_only_with.py @@ -0,0 +1,34 @@ +# flags: --minimum-version=3.10 + +with open("bug.txt", "r", encoding="utf-8") as fh1: + pass +# fmt: off +# fmt: on +# xxx +# fmt: off +# fmt: on +with open("bug.txt", "r", encoding="utf-8") as fh2: + pass +def fn(str: str) -> float: + match str: + case _: + pass + +# output + +with open("bug.txt", "r", encoding="utf-8") as fh1: + pass +# fmt: off +# fmt: on + +# xxx +# fmt: off +# fmt: on +with open("bug.txt", "r", encoding="utf-8") as fh2: + pass + + +def fn(str: str) -> float: + match str: + case _: + pass diff --git a/tests/data/cases/fmtpass_imports.py b/tests/data/cases/fmtpass_imports.py new file mode 100644 index 0000000..8b3c0bc --- /dev/null +++ b/tests/data/cases/fmtpass_imports.py @@ -0,0 +1,19 @@ +# Regression test for https://github.com/psf/black/issues/3438 + +import ast +import collections # fmt: skip +import dataclasses +# fmt: off +import os +# fmt: on +import pathlib + +import re # fmt: skip +import secrets + +# fmt: off +import sys +# fmt: on + +import tempfile +import zoneinfo diff --git a/tests/data/cases/fmtskip.py b/tests/data/cases/fmtskip.py new file mode 100644 index 0000000..1d5836f --- /dev/null +++ b/tests/data/cases/fmtskip.py @@ -0,0 +1,3 @@ +a, b = 1, 2 +c = 6 # fmt: skip +d = 5 diff --git a/tests/data/cases/fmtskip10.py b/tests/data/cases/fmtskip10.py new file mode 100644 index 0000000..640ac4d --- /dev/null +++ b/tests/data/cases/fmtskip10.py @@ -0,0 +1,21 @@ +def foo(): return "mock" # fmt: skip +if True: print("yay") # fmt: skip +for i in range(10): print(i) # fmt: skip +if True: print("this"); print("that") # fmt: skip +while True: print("loop"); break # fmt: skip +for x in [1, 2]: print(x); print("done") # fmt: skip +def f(x: int): return x # fmt: skip + +j = 1 # fmt: skip +while j < 10: j += 1 # fmt: skip + +b = [c for c in "A very long string that would normally generate some kind of collapse, since it is this long"] # fmt: skip + +v = ( + foo_dict # fmt: skip + .setdefault("a", {}) + .setdefault("b", {}) + .setdefault("c", {}) + .setdefault("d", {}) + .setdefault("e", {}) +) diff --git a/tests/data/cases/fmtskip11.py b/tests/data/cases/fmtskip11.py new file mode 100644 index 0000000..2b0e1e8 --- /dev/null +++ b/tests/data/cases/fmtskip11.py @@ -0,0 +1,88 @@ +def foo(): + pass + + +# comment 1 # fmt: skip +# comment 2 + +[ + (1, 2), + # # fmt: off + # (3, + # 4), + # # fmt: on + (5, 6), +] + +[ + (1, 2), + # # fmt: off + # (3, + # 4), + # fmt: on + (5, 6), +] + + +[ + (1, 2), + # fmt: off + # (3, + # 4), + # # fmt: on + (5, 6), +] + + +[ + (1, 2), + # fmt: off + # (3, + # 4), + # fmt: on + (5, 6), +] + +[ + (1, 2), + # # fmt: off + (3, + 4), + # # fmt: on + (5, 6), +] + +[ + (1, 2), + # # fmt: off + (3, + 4), + # fmt: on + (5, 6), +] + + +[ + (1, 2), + # fmt: off + (3, + 4), + # # fmt: on + (5, 6), +] + + +[ + (1, 2), + # fmt: off + (3, + 4), + # fmt: on + (5, 6), +] + + +if False: + # fmt: off # some other comment + pass + diff --git a/tests/data/cases/fmtskip12.py b/tests/data/cases/fmtskip12.py new file mode 100644 index 0000000..217fc2b --- /dev/null +++ b/tests/data/cases/fmtskip12.py @@ -0,0 +1,19 @@ +with open("file.txt") as f: content = f.read() # fmt: skip + +# Ideally, only the last line would be ignored +# But ignoring only part of the asexpr_test causes a parse error +# Same with ignoring the asexpr_test without also ignoring the entire with_stmt +with open ( + "file.txt" , +) as f: content = f.read() # fmt: skip + +# output + +with open("file.txt") as f: content = f.read() # fmt: skip + +# Ideally, only the last line would be ignored +# But ignoring only part of the asexpr_test causes a parse error +# Same with ignoring the asexpr_test without also ignoring the entire with_stmt +with open ( + "file.txt" , +) as f: content = f.read() # fmt: skip diff --git a/tests/data/cases/fmtskip13.py b/tests/data/cases/fmtskip13.py new file mode 100644 index 0000000..1f2d534 --- /dev/null +++ b/tests/data/cases/fmtskip13.py @@ -0,0 +1,62 @@ +t = ( + {"foo": "very long string", "bar": "another very long string", "baz": "we should run out of space by now"}, # fmt: skip + {"foo": "bar"}, +) + +t = ( + { + "foo": "very long string", + "bar": "another very long string", + "baz": "we should run out of space by now", + }, # fmt: skip + {"foo": "bar"}, +) + + +t = ( + {"foo": "very long string", "bar": "another very long string", "baz": "we should run out of space by now"}, # fmt: skip + {"foo": "bar",}, +) + +t = ( + { + "foo": "very long string", + "bar": "another very long string", + "baz": "we should run out of space by now", + }, # fmt: skip + {"foo": "bar",}, +) + +# output +t = ( + {"foo": "very long string", "bar": "another very long string", "baz": "we should run out of space by now"}, # fmt: skip + {"foo": "bar"}, +) + +t = ( + { + "foo": "very long string", + "bar": "another very long string", + "baz": "we should run out of space by now", + }, # fmt: skip + {"foo": "bar"}, +) + + +t = ( + {"foo": "very long string", "bar": "another very long string", "baz": "we should run out of space by now"}, # fmt: skip + { + "foo": "bar", + }, +) + +t = ( + { + "foo": "very long string", + "bar": "another very long string", + "baz": "we should run out of space by now", + }, # fmt: skip + { + "foo": "bar", + }, +) diff --git a/tests/data/cases/fmtskip2.py b/tests/data/cases/fmtskip2.py new file mode 100644 index 0000000..0189d4e --- /dev/null +++ b/tests/data/cases/fmtskip2.py @@ -0,0 +1,20 @@ +# flags: --no-preview-line-length-1 +# l2 loses the comment with line-length=1 in preview mode +l1 = ["This list should be broken up", "into multiple lines", "because it is way too long"] +l2 = ["But this list shouldn't", "even though it also has", "way too many characters in it"] # fmt: skip +l3 = ["I have", "trailing comma", "so I should be braked",] + +# output + +# l2 loses the comment with line-length=1 in preview mode +l1 = [ + "This list should be broken up", + "into multiple lines", + "because it is way too long", +] +l2 = ["But this list shouldn't", "even though it also has", "way too many characters in it"] # fmt: skip +l3 = [ + "I have", + "trailing comma", + "so I should be braked", +] diff --git a/tests/data/cases/fmtskip3.py b/tests/data/cases/fmtskip3.py new file mode 100644 index 0000000..6e16688 --- /dev/null +++ b/tests/data/cases/fmtskip3.py @@ -0,0 +1,20 @@ +a = 3 +# fmt: off +b, c = 1, 2 +d = 6 # fmt: skip +e = 5 +# fmt: on +f = ["This is a very long line that should be formatted into a clearer line ", "by rearranging."] + +# output + +a = 3 +# fmt: off +b, c = 1, 2 +d = 6 # fmt: skip +e = 5 +# fmt: on +f = [ + "This is a very long line that should be formatted into a clearer line ", + "by rearranging.", +] diff --git a/tests/data/cases/fmtskip4.py b/tests/data/cases/fmtskip4.py new file mode 100644 index 0000000..aadd77d --- /dev/null +++ b/tests/data/cases/fmtskip4.py @@ -0,0 +1,13 @@ +a = 2 +# fmt: skip +l = [1, 2, 3,] + +# output + +a = 2 +# fmt: skip +l = [ + 1, + 2, + 3, +] \ No newline at end of file diff --git a/tests/data/cases/fmtskip5.py b/tests/data/cases/fmtskip5.py new file mode 100644 index 0000000..d7b15e0 --- /dev/null +++ b/tests/data/cases/fmtskip5.py @@ -0,0 +1,22 @@ +a, b, c = 3, 4, 5 +if ( + a == 3 + and b != 9 # fmt: skip + and c is not None +): + print("I'm good!") +else: + print("I'm bad") + + +# output + +a, b, c = 3, 4, 5 +if ( + a == 3 + and b != 9 # fmt: skip + and c is not None +): + print("I'm good!") +else: + print("I'm bad") diff --git a/tests/data/cases/fmtskip6.py b/tests/data/cases/fmtskip6.py new file mode 100644 index 0000000..0a779fc --- /dev/null +++ b/tests/data/cases/fmtskip6.py @@ -0,0 +1,13 @@ +class A: + def f(self): + for line in range(10): + if True: + pass # fmt: skip + +# output + +class A: + def f(self): + for line in range(10): + if True: + pass # fmt: skip diff --git a/tests/data/cases/fmtskip7.py b/tests/data/cases/fmtskip7.py new file mode 100644 index 0000000..89b2951 --- /dev/null +++ b/tests/data/cases/fmtskip7.py @@ -0,0 +1,11 @@ +a = "this is some code" +b = 5 # fmt:skip +c = 9 #fmt: skip +d = "thisisasuperlongstringthisisasuperlongstringthisisasuperlongstringthisisasuperlongstring" # fmt:skip + +# output + +a = "this is some code" +b = 5 # fmt:skip +c = 9 #fmt: skip +d = "thisisasuperlongstringthisisasuperlongstringthisisasuperlongstringthisisasuperlongstring" # fmt:skip diff --git a/tests/data/cases/fmtskip8.py b/tests/data/cases/fmtskip8.py new file mode 100644 index 0000000..38e9c2a --- /dev/null +++ b/tests/data/cases/fmtskip8.py @@ -0,0 +1,62 @@ +# Make sure a leading comment is not removed. +def some_func( unformatted, args ): # fmt: skip + print("I am some_func") + return 0 + # Make sure this comment is not removed. + + +# Make sure a leading comment is not removed. +async def some_async_func( unformatted, args): # fmt: skip + print("I am some_async_func") + await asyncio.sleep(1) + + +# Make sure a leading comment is not removed. +class SomeClass( Unformatted, SuperClasses ): # fmt: skip + def some_method( self, unformatted, args ): # fmt: skip + print("I am some_method") + return 0 + + async def some_async_method( self, unformatted, args ): # fmt: skip + print("I am some_async_method") + await asyncio.sleep(1) + + +# Make sure a leading comment is not removed. +if unformatted_call( args ): # fmt: skip + print("First branch") + # Make sure this is not removed. +elif another_unformatted_call( args ): # fmt: skip + print("Second branch") +else : # fmt: skip + print("Last branch") + + +while some_condition( unformatted, args ): # fmt: skip + print("Do something") + + +for i in some_iter( unformatted, args ): # fmt: skip + print("Do something") + + +async def test_async_for(): + async for i in some_async_iter( unformatted, args ): # fmt: skip + print("Do something") + + +try : # fmt: skip + some_call() +except UnformattedError as ex: # fmt: skip + handle_exception() +finally : # fmt: skip + finally_call() + + +with give_me_context( unformatted, args ): # fmt: skip + print("Do something") + + +async def test_async_with(): + async with give_me_async_context( unformatted, args ): # fmt: skip + print("Do something") diff --git a/tests/data/cases/fmtskip9.py b/tests/data/cases/fmtskip9.py new file mode 100644 index 0000000..d070a7f --- /dev/null +++ b/tests/data/cases/fmtskip9.py @@ -0,0 +1,8 @@ +print () # fmt: skip +print () # fmt:skip + + +# output + +print () # fmt: skip +print () # fmt:skip diff --git a/tests/data/cases/fmtskip_after_bracket_with_comment.py b/tests/data/cases/fmtskip_after_bracket_with_comment.py new file mode 100644 index 0000000..77f2fb5 --- /dev/null +++ b/tests/data/cases/fmtskip_after_bracket_with_comment.py @@ -0,0 +1,27 @@ +# A `# fmt: skip` on a line that opens a bracket, combined with a standalone +# comment among the bracket's contents, used to crash inside +# `is_line_short_enough` with `AttributeError: 'Leaf' object has no attribute +# 'bracket_depth'`. The whole statement should now be left untouched. + +from m import ( +# fmt: skip + # comment + a +) + +f( +# fmt: skip + # comment + a +) + +x[ +# fmt: skip + # comment + a +] + +from m import ( # fmt: skip + # comment + a +) diff --git a/tests/data/cases/fmtskip_class_header.py b/tests/data/cases/fmtskip_class_header.py new file mode 100644 index 0000000..938eb5d --- /dev/null +++ b/tests/data/cases/fmtskip_class_header.py @@ -0,0 +1,47 @@ +class Body(model.BaseBody[ + "Keyword", "For", "While", "Group", "If", "Try", "Var", "Return", "Continue", + "Break", "model.Message", "Error" +]): # fmt: skip + __slots__ = () + + +class Foo(Base[\ + "A", "B"\ +]): # fmt: skip + + def a(self): ... + + +def make_result( + first : int, + second: str, +): # fmt: skip + return first, second + + +async def fetch_result( + client, + *, + timeout = 1, +): # fmt: skip + return await client.fetch(timeout=timeout) + + +if ( + has_permission( user ) + and is_ready( item ) +): # fmt: skip + process(item) + +match (method, *path.split("/")): + case ("GET", "parent", _, "resource", resource_id) \ + | ("GET", "resource", resource_id): # fmt: skip + pass + case _: + pass + +match x: + case a \ + | b \ + | c: # fmt: skip + pass diff --git a/tests/data/cases/fmtskip_in_clause.py b/tests/data/cases/fmtskip_in_clause.py new file mode 100644 index 0000000..fb79254 --- /dev/null +++ b/tests/data/cases/fmtskip_in_clause.py @@ -0,0 +1,43 @@ +# Single fmt: skip in multi-part if-clause +class ClassWithALongName: + Constant1 = 1 + Constant2 = 2 + Constant3 = 3 + + +def test(): + if ( + "cond1" == "cond1" + and "cond2" == "cond2" + and 1 in ( # fmt: skip + ClassWithALongName.Constant1, + ClassWithALongName.Constant2, + ClassWithALongName.Constant3, + ) + ): + return True + return False + + +# output + + +# Single fmt: skip in multi-part if-clause +class ClassWithALongName: + Constant1 = 1 + Constant2 = 2 + Constant3 = 3 + + +def test(): + if ( + "cond1" == "cond1" + and "cond2" == "cond2" + and 1 in ( # fmt: skip + ClassWithALongName.Constant1, + ClassWithALongName.Constant2, + ClassWithALongName.Constant3, + ) + ): + return True + return False diff --git a/tests/data/cases/fmtskip_in_parens.py b/tests/data/cases/fmtskip_in_parens.py new file mode 100644 index 0000000..4802205 --- /dev/null +++ b/tests/data/cases/fmtskip_in_parens.py @@ -0,0 +1,49 @@ +# Regression tests for https://github.com/psf/black/issues/4513. +# Fixed by #4903 ("Improve fmt:skip handling in nested expressions with checks"). +# Each of the three inputs below used to crash with a "Cannot parse" error. + +# Case A: triple-quoted string inside parens with a leading `# fmt: skip` line. +( +# fmt: skip +""" +""" +) + +# Case B: line-continued string inside parens with a leading `# fmt: skip` line. +( +# fmt: skip +"\ +" +) + +# Case C: `# fmt: skip` on the opening paren of a comparator expression. +foo = ( # fmt: skip + some_long_expression + > some_other_long_expression +) + +# output + +# Regression tests for https://github.com/psf/black/issues/4513. +# Fixed by #4903 ("Improve fmt:skip handling in nested expressions with checks"). +# Each of the three inputs below used to crash with a "Cannot parse" error. + +# Case A: triple-quoted string inside parens with a leading `# fmt: skip` line. +( +# fmt: skip +""" +""" +) + +# Case B: line-continued string inside parens with a leading `# fmt: skip` line. +( +# fmt: skip +"\ +" +) + +# Case C: `# fmt: skip` on the opening paren of a comparator expression. +foo = ( # fmt: skip + some_long_expression + > some_other_long_expression +) diff --git a/tests/data/cases/fmtskip_multiple_in_clause.py b/tests/data/cases/fmtskip_multiple_in_clause.py new file mode 100644 index 0000000..7a47e90 --- /dev/null +++ b/tests/data/cases/fmtskip_multiple_in_clause.py @@ -0,0 +1,43 @@ +# Multiple fmt: skip in multi-part if-clause +class ClassWithALongName: + Constant1 = 1 + Constant2 = 2 + Constant3 = 3 + + +def test(): + if ( + "cond1" == "cond1" + and "cond2" == "cond2" + and 1 in ( + ClassWithALongName.Constant1, + ClassWithALongName.Constant2, + ClassWithALongName.Constant3, # fmt: skip + ) # fmt: skip + ): + return True + return False + + +# output + + +# Multiple fmt: skip in multi-part if-clause +class ClassWithALongName: + Constant1 = 1 + Constant2 = 2 + Constant3 = 3 + + +def test(): + if ( + "cond1" == "cond1" + and "cond2" == "cond2" + and 1 in ( + ClassWithALongName.Constant1, + ClassWithALongName.Constant2, + ClassWithALongName.Constant3, # fmt: skip + ) # fmt: skip + ): + return True + return False diff --git a/tests/data/cases/fmtskip_multiple_strings.py b/tests/data/cases/fmtskip_multiple_strings.py new file mode 100644 index 0000000..3ba70a6 --- /dev/null +++ b/tests/data/cases/fmtskip_multiple_strings.py @@ -0,0 +1,75 @@ +# Multiple fmt: skip on string literals +a = ( + "this should " # fmt: skip + "be fine" +) + +b = ( + "this is " # fmt: skip + "not working" # fmt: skip +) + +c = ( + "and neither " # fmt: skip + "is this " # fmt: skip + "working" +) + +d = ( + "nor " + "is this " # fmt: skip + "working" # fmt: skip +) + +e = ( + "and this " # fmt: skip + "is definitely " + "not working" # fmt: skip +) + +# Dictionary entries with fmt: skip (covers issue with long lines) +hotkeys = { + "editor:swap-line-down": [{"key": "ArrowDown", "modifiers": ["Alt", "Mod"]}], # fmt: skip + "editor:swap-line-up": [{"key": "ArrowUp", "modifiers": ["Alt", "Mod"]}], # fmt: skip + "editor:toggle-source": [{"key": "S", "modifiers": ["Alt", "Mod"]}], # fmt: skip +} + + +# output + + +# Multiple fmt: skip on string literals +a = ( + "this should " # fmt: skip + "be fine" +) + +b = ( + "this is " # fmt: skip + "not working" # fmt: skip +) + +c = ( + "and neither " # fmt: skip + "is this " # fmt: skip + "working" +) + +d = ( + "nor " + "is this " # fmt: skip + "working" # fmt: skip +) + +e = ( + "and this " # fmt: skip + "is definitely " + "not working" # fmt: skip +) + +# Dictionary entries with fmt: skip (covers issue with long lines) +hotkeys = { + "editor:swap-line-down": [{"key": "ArrowDown", "modifiers": ["Alt", "Mod"]}], # fmt: skip + "editor:swap-line-up": [{"key": "ArrowUp", "modifiers": ["Alt", "Mod"]}], # fmt: skip + "editor:toggle-source": [{"key": "S", "modifiers": ["Alt", "Mod"]}], # fmt: skip +} diff --git a/tests/data/cases/fmtskip_type_ignore.py b/tests/data/cases/fmtskip_type_ignore.py new file mode 100644 index 0000000..293690f --- /dev/null +++ b/tests/data/cases/fmtskip_type_ignore.py @@ -0,0 +1,2 @@ +a = 1 # type: ignore +b = 1 # fmt: skip diff --git a/tests/data/cases/form_feeds.py b/tests/data/cases/form_feeds.py new file mode 100644 index 0000000..957b4a1 --- /dev/null +++ b/tests/data/cases/form_feeds.py @@ -0,0 +1,227 @@ + + +# Warning! This file contains form feeds (ASCII 0x0C, often represented by \f or ^L). +# These may be invisible in your editor: ensure you can see them before making changes here. + +# There's one at the start that'll get stripped + +# Comment and statement processing is different enough that we'll test variations of both +# contexts here + +# + + +# + + +# + + + +# + + + +# + + + +# + + +# + + + +# + +# + +# + + \ +# +pass + +pass + + +pass + + +pass + + + +pass + + + +pass + + + +pass + + +pass + + + +pass + +pass + +pass + + +# form feed after a dedent +def foo(): + pass + +pass + + +# form feeds are prohibited inside blocks, or on a line with nonwhitespace + def bar( a = 1 ,b : bool = False ) : + + + pass + + +class Baz: + + def __init__(self): + pass + + + def something(self): + pass + + + +# +pass +pass # +a = 1 + # + pass + a = 1 + +a = [ + +] + +# as internal whitespace of a comment is allowed but why +"form feed literal in a string is okay " + +# form feeds at the very end get removed. + + + +# output + +# Warning! This file contains form feeds (ASCII 0x0C, often represented by \f or ^L). +# These may be invisible in your editor: ensure you can see them before making changes here. + +# There's one at the start that'll get stripped + +# Comment and statement processing is different enough that we'll test variations of both +# contexts here + +# + + +# + + +# + + +# + + +# + + +# + + +# + + +# + +# + +# + + +# +pass + +pass + + +pass + + +pass + + +pass + + +pass + + +pass + + +pass + + +pass + +pass + +pass + + +# form feed after a dedent +def foo(): + pass + + +pass + + +# form feeds are prohibited inside blocks, or on a line with nonwhitespace +def bar(a=1, b: bool = False): + + pass + + +class Baz: + + def __init__(self): + pass + + def something(self): + pass + + +# +pass +pass # +a = 1 +# +pass +a = 1 + +a = [] + +# as internal whitespace of a comment is allowed but why +"form feed literal in a string is okay " + +# form feeds at the very end get removed. diff --git a/tests/data/cases/format_unicode_escape_seq.py b/tests/data/cases/format_unicode_escape_seq.py new file mode 100644 index 0000000..3440696 --- /dev/null +++ b/tests/data/cases/format_unicode_escape_seq.py @@ -0,0 +1,33 @@ +x = "\x1F" +x = "\\x1B" +x = "\\\x1B" +x = "\U0001F60E" +x = "\u0001F60E" +x = r"\u0001F60E" +x = "don't format me" +x = "\xA3" +x = "\u2717" +x = "\uFaCe" +x = "\N{ox}\N{OX}" +x = "\N{lAtIn smaLL letteR x}" +x = "\N{CYRILLIC small LETTER BYELORUSSIAN-UKRAINIAN I}" +x = b"\x1Fdon't byte" +x = rb"\x1Fdon't format" + +# output + +x = "\x1f" +x = "\\x1B" +x = "\\\x1b" +x = "\U0001f60e" +x = "\u0001F60E" +x = r"\u0001F60E" +x = "don't format me" +x = "\xa3" +x = "\u2717" +x = "\uface" +x = "\N{OX}\N{OX}" +x = "\N{LATIN SMALL LETTER X}" +x = "\N{CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I}" +x = b"\x1fdon't byte" +x = rb"\x1Fdon't format" diff --git a/tests/data/cases/fstring.py b/tests/data/cases/fstring.py new file mode 100644 index 0000000..6056030 --- /dev/null +++ b/tests/data/cases/fstring.py @@ -0,0 +1,25 @@ +f"f-string without formatted values is just a string" +f"{{NOT a formatted value}}" +f"{{NOT 'a' \"formatted\" \"value\"}}" +f"some f-string with {a} {few():.2f} {formatted.values!r}" +f'some f-string with {a} {few(""):.2f} {formatted.values!r}' +f"{f'''{'nested'} inner'''} outer" +f"\"{f'{nested} inner'}\" outer" +f"space between opening braces: { {a for a in (1, 2, 3)}}" +f'Hello \'{tricky + "example"}\'' +f"Tried directories {str(rootdirs)} \ +but none started with prefix {parentdir_prefix}" + +# output + +f"f-string without formatted values is just a string" +f"{{NOT a formatted value}}" +f'{{NOT \'a\' "formatted" "value"}}' +f"some f-string with {a} {few():.2f} {formatted.values!r}" +f'some f-string with {a} {few(""):.2f} {formatted.values!r}' +f"{f'''{'nested'} inner'''} outer" +f"\"{f'{nested} inner'}\" outer" +f"space between opening braces: { {a for a in (1, 2, 3)}}" +f'Hello \'{tricky + "example"}\'' +f"Tried directories {str(rootdirs)} \ +but none started with prefix {parentdir_prefix}" diff --git a/tests/data/cases/fstring_quotations.py b/tests/data/cases/fstring_quotations.py new file mode 100644 index 0000000..c1cb430 --- /dev/null +++ b/tests/data/cases/fstring_quotations.py @@ -0,0 +1,67 @@ +# Regression tests for long f-strings, including examples from issue #3623 + +a = ( + 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' + f'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"{"b"}"' +) + +a = ( + f'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"{"b"}"' + 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' +) + +a = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' + \ + f'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"{"b"}"' + +a = f'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"{"b"}"' + \ + f'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"{"b"}"' + +a = ( + f'bbbbbbb"{"b"}"' + 'aaaaaaaa' +) + +a = ( + f'"{"b"}"' +) + +a = ( + f'\"{"b"}\"' +) + +a = ( + r'\"{"b"}\"' +) + +# output + +# Regression tests for long f-strings, including examples from issue #3623 + +a = ( + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + f'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"{"b"}"' +) + +a = ( + f'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"{"b"}"' + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" +) + +a = ( + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + + f'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"{"b"}"' +) + +a = ( + f'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"{"b"}"' + + f'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"{"b"}"' +) + +a = f'bbbbbbb"{"b"}"' "aaaaaaaa" + +a = f'"{"b"}"' + +a = f'"{"b"}"' + +a = r'\"{"b"}\"' + diff --git a/tests/data/cases/funcdef_return_type_trailing_comma.py b/tests/data/cases/funcdef_return_type_trailing_comma.py new file mode 100644 index 0000000..6335cf7 --- /dev/null +++ b/tests/data/cases/funcdef_return_type_trailing_comma.py @@ -0,0 +1,302 @@ +# flags: --minimum-version=3.10 +# normal, short, function definition +def foo(a, b) -> tuple[int, float]: ... + + +# normal, short, function definition w/o return type +def foo(a, b): ... + + +# no splitting +def foo(a: A, b: B) -> list[p, q]: + pass + + +# magic trailing comma in param list +def foo(a, b,): ... + + +# magic trailing comma in nested params in param list +def foo(a, b: tuple[int, float,]): ... + + +# magic trailing comma in return type, no params +def a() -> tuple[ + a, + b, +]: ... + + +# magic trailing comma in return type, params +def foo(a: A, b: B) -> list[ + p, + q, +]: + pass + + +# magic trailing comma in param list and in return type +def foo( + a: a, + b: b, +) -> list[ + a, + a, +]: + pass + + +# long function definition, param list is longer +def aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa( + bbbbbbbbbbbbbbbbbb, +) -> cccccccccccccccccccccccccccccc: ... + + +# long function definition, return type is longer +# this should maybe split on rhs? +def aaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbb) -> list[ + Ccccccccccccccccccccccccccccccccccccccccccccccccccc, Dddddd +]: ... + + +# long return type, no param list +def foo() -> list[ + Loooooooooooooooooooooooooooooooooooong, + Loooooooooooooooooooong, + Looooooooooooong, +]: ... + + +# long function name, no param list, no return value +def thiiiiiiiiiiiiiiiiiis_iiiiiiiiiiiiiiiiiiiiiiiiiiiiiis_veeeeeeeeeeeeeeeeeeeeeeery_looooooong(): + pass + + +# long function name, no param list +def thiiiiiiiiiiiiiiiiiis_iiiiiiiiiiiiiiiiiiiiiiiiiiiiiis_veeeeeeeeeeeeeeeeeeeeeeery_looooooong() -> ( + list[int, float] +): ... + + +# long function name, no return value +def thiiiiiiiiiiiiiiiiiis_iiiiiiiiiiiiiiiiiiiiiiiiiiiiiis_veeeeeeeeeeeeeeeeeeeeeeery_looooooong( + a, b +): ... + + +# unskippable type hint (??) +def foo(a) -> list[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]: # type: ignore + pass + + +def foo(a) -> list[ + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +]: # abpedeifnore + pass + +def foo(a, b: list[Bad],): ... # type: ignore + +# don't lose any comments (no magic) +def foo( # 1 + a, # 2 + b) -> list[ # 3 + a, # 4 + b]: # 5 + ... # 6 + + +# don't lose any comments (param list magic) +def foo( # 1 + a, # 2 + b,) -> list[ # 3 + a, # 4 + b]: # 5 + ... # 6 + + +# don't lose any comments (return type magic) +def foo( # 1 + a, # 2 + b) -> list[ # 3 + a, # 4 + b,]: # 5 + ... # 6 + + +# don't lose any comments (both magic) +def foo( # 1 + a, # 2 + b,) -> list[ # 3 + a, # 4 + b,]: # 5 + ... # 6 + +# real life example +def SimplePyFn( + context: hl.GeneratorContext, + buffer_input: Buffer[UInt8, 2], + func_input: Buffer[Int32, 2], + float_arg: Scalar[Float32], + offset: int = 0, +) -> tuple[ + Buffer[UInt8, 2], + Buffer[UInt8, 2], +]: ... + +# output +# normal, short, function definition +def foo(a, b) -> tuple[int, float]: ... + + +# normal, short, function definition w/o return type +def foo(a, b): ... + + +# no splitting +def foo(a: A, b: B) -> list[p, q]: + pass + + +# magic trailing comma in param list +def foo( + a, + b, +): ... + + +# magic trailing comma in nested params in param list +def foo( + a, + b: tuple[ + int, + float, + ], +): ... + + +# magic trailing comma in return type, no params +def a() -> tuple[ + a, + b, +]: ... + + +# magic trailing comma in return type, params +def foo(a: A, b: B) -> list[ + p, + q, +]: + pass + + +# magic trailing comma in param list and in return type +def foo( + a: a, + b: b, +) -> list[ + a, + a, +]: + pass + + +# long function definition, param list is longer +def aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa( + bbbbbbbbbbbbbbbbbb, +) -> cccccccccccccccccccccccccccccc: ... + + +# long function definition, return type is longer +# this should maybe split on rhs? +def aaaaaaaaaaaaaaaaa( + bbbbbbbbbbbbbbbbbb, +) -> list[Ccccccccccccccccccccccccccccccccccccccccccccccccccc, Dddddd]: ... + + +# long return type, no param list +def foo() -> list[ + Loooooooooooooooooooooooooooooooooooong, + Loooooooooooooooooooong, + Looooooooooooong, +]: ... + + +# long function name, no param list, no return value +def thiiiiiiiiiiiiiiiiiis_iiiiiiiiiiiiiiiiiiiiiiiiiiiiiis_veeeeeeeeeeeeeeeeeeeeeeery_looooooong(): + pass + + +# long function name, no param list +def thiiiiiiiiiiiiiiiiiis_iiiiiiiiiiiiiiiiiiiiiiiiiiiiiis_veeeeeeeeeeeeeeeeeeeeeeery_looooooong() -> ( + list[int, float] +): ... + + +# long function name, no return value +def thiiiiiiiiiiiiiiiiiis_iiiiiiiiiiiiiiiiiiiiiiiiiiiiiis_veeeeeeeeeeeeeeeeeeeeeeery_looooooong( + a, b +): ... + + +# unskippable type hint (??) +def foo(a) -> list[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]: # type: ignore + pass + + +def foo( + a, +) -> list[ + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +]: # abpedeifnore + pass + + +def foo( + a, + b: list[Bad], +): ... # type: ignore + + +# don't lose any comments (no magic) +def foo(a, b) -> list[a, b]: # 1 # 2 # 3 # 4 # 5 + ... # 6 + + +# don't lose any comments (param list magic) +def foo( # 1 + a, # 2 + b, +) -> list[a, b]: # 3 # 4 # 5 + ... # 6 + + +# don't lose any comments (return type magic) +def foo(a, b) -> list[ # 1 # 2 # 3 + a, # 4 + b, +]: # 5 + ... # 6 + + +# don't lose any comments (both magic) +def foo( # 1 + a, # 2 + b, +) -> list[ # 3 + a, # 4 + b, +]: # 5 + ... # 6 + + +# real life example +def SimplePyFn( + context: hl.GeneratorContext, + buffer_input: Buffer[UInt8, 2], + func_input: Buffer[Int32, 2], + float_arg: Scalar[Float32], + offset: int = 0, +) -> tuple[ + Buffer[UInt8, 2], + Buffer[UInt8, 2], +]: ... diff --git a/tests/data/cases/function.py b/tests/data/cases/function.py new file mode 100644 index 0000000..4e3f91f --- /dev/null +++ b/tests/data/cases/function.py @@ -0,0 +1,244 @@ +#!/usr/bin/env python3 +import asyncio +import sys + +from third_party import X, Y, Z + +from library import some_connection, \ + some_decorator +f'trigger 3.6 mode' +def func_no_args(): + a; b; c + if True: raise RuntimeError + if False: ... + for i in range(10): + print(i) + continue + exec("new-style exec", {}, {}) + return None +async def coroutine(arg, exec=False): + "Single-line docstring. Multiline is harder to reformat." + async with some_connection() as conn: + await conn.do_what_i_mean('SELECT bobby, tables FROM xkcd', timeout=2) + await asyncio.sleep(1) +@asyncio.coroutine +@some_decorator( +with_args=True, +many_args=[1,2,3] +) +def function_signature_stress_test(number:int,no_annotation=None,text:str="default",* ,debug:bool=False,**kwargs) -> str: + return text[number:-1] +def spaces(a=1, b=(), c=[], d={}, e=True, f=-1, g=1 if False else 2, h="", i=r''): + offset = attr.ib(default=attr.Factory( lambda: _r.uniform(10000, 200000))) + assert task._cancel_stack[:len(old_stack)] == old_stack +def spaces_types(a: int = 1, b: tuple = (), c: list = [], d: dict = {}, e: bool = True, f: int = -1, g: int = 1 if False else 2, h: str = "", i: str = r''): ... +def spaces2(result= _core.Value(None)): + assert fut is self._read_fut, (fut, self._read_fut) + # EMPTY LINE WITH WHITESPACE (this comment will be removed) +def example(session): + result = session.query(models.Customer.id).filter( + models.Customer.account_id == account_id, + models.Customer.email == email_address, + ).order_by( + models.Customer.id.asc() + ).all() +def long_lines(): + if True: + typedargslist.extend( + gen_annotated_params(ast_args.kwonlyargs, ast_args.kw_defaults, parameters, implicit_default=True) + ) + typedargslist.extend( + gen_annotated_params( + ast_args.kwonlyargs, ast_args.kw_defaults, parameters, implicit_default=True, + # trailing standalone comment + ) + ) + _type_comment_re = re.compile( + r""" + ^ + [\t ]* + \#[ ]type:[ ]* + (?P + [^#\t\n]+? + ) + (? to match + # a trailing space which is why we need the silliness below + (? + (?:\#[^\n]*)? + \n? + ) + $ + """, re.MULTILINE | re.VERBOSE + ) +def trailing_comma(): + mapping = { + A: 0.25 * (10.0 / 12), + B: 0.1 * (10.0 / 12), + C: 0.1 * (10.0 / 12), + D: 0.1 * (10.0 / 12), +} +def f( + a, + **kwargs, +) -> A: + return ( + yield from A( + very_long_argument_name1=very_long_value_for_the_argument, + very_long_argument_name2=very_long_value_for_the_argument, + **kwargs, + ) + ) +def __await__(): return (yield) + +# output + + +#!/usr/bin/env python3 +import asyncio +import sys + +from third_party import X, Y, Z + +from library import some_connection, some_decorator + +f"trigger 3.6 mode" + + +def func_no_args(): + a + b + c + if True: + raise RuntimeError + if False: + ... + for i in range(10): + print(i) + continue + exec("new-style exec", {}, {}) + return None + + +async def coroutine(arg, exec=False): + "Single-line docstring. Multiline is harder to reformat." + async with some_connection() as conn: + await conn.do_what_i_mean("SELECT bobby, tables FROM xkcd", timeout=2) + await asyncio.sleep(1) + + +@asyncio.coroutine +@some_decorator(with_args=True, many_args=[1, 2, 3]) +def function_signature_stress_test( + number: int, + no_annotation=None, + text: str = "default", + *, + debug: bool = False, + **kwargs, +) -> str: + return text[number:-1] + + +def spaces(a=1, b=(), c=[], d={}, e=True, f=-1, g=1 if False else 2, h="", i=r""): + offset = attr.ib(default=attr.Factory(lambda: _r.uniform(10000, 200000))) + assert task._cancel_stack[: len(old_stack)] == old_stack + + +def spaces_types( + a: int = 1, + b: tuple = (), + c: list = [], + d: dict = {}, + e: bool = True, + f: int = -1, + g: int = 1 if False else 2, + h: str = "", + i: str = r"", +): ... +def spaces2(result=_core.Value(None)): + assert fut is self._read_fut, (fut, self._read_fut) + + +def example(session): + result = ( + session.query(models.Customer.id) + .filter( + models.Customer.account_id == account_id, + models.Customer.email == email_address, + ) + .order_by(models.Customer.id.asc()) + .all() + ) + + +def long_lines(): + if True: + typedargslist.extend( + gen_annotated_params( + ast_args.kwonlyargs, + ast_args.kw_defaults, + parameters, + implicit_default=True, + ) + ) + typedargslist.extend( + gen_annotated_params( + ast_args.kwonlyargs, + ast_args.kw_defaults, + parameters, + implicit_default=True, + # trailing standalone comment + ) + ) + _type_comment_re = re.compile( + r""" + ^ + [\t ]* + \#[ ]type:[ ]* + (?P + [^#\t\n]+? + ) + (? to match + # a trailing space which is why we need the silliness below + (? + (?:\#[^\n]*)? + \n? + ) + $ + """, + re.MULTILINE | re.VERBOSE, + ) + + +def trailing_comma(): + mapping = { + A: 0.25 * (10.0 / 12), + B: 0.1 * (10.0 / 12), + C: 0.1 * (10.0 / 12), + D: 0.1 * (10.0 / 12), + } + + +def f( + a, + **kwargs, +) -> A: + return ( + yield from A( + very_long_argument_name1=very_long_value_for_the_argument, + very_long_argument_name2=very_long_value_for_the_argument, + **kwargs, + ) + ) + + +def __await__(): + return (yield) diff --git a/tests/data/cases/function2.py b/tests/data/cases/function2.py new file mode 100644 index 0000000..5bb36c2 --- /dev/null +++ b/tests/data/cases/function2.py @@ -0,0 +1,121 @@ +def f( + a, + **kwargs, +) -> A: + with cache_dir(): + if something: + result = ( + CliRunner().invoke(black.main, [str(src1), str(src2), "--diff", "--check"]) + ) + limited.append(-limited.pop()) # negate top + return A( + very_long_argument_name1=very_long_value_for_the_argument, + very_long_argument_name2=-very.long.value.for_the_argument, + **kwargs, + ) +def g(): + "Docstring." + def inner(): + pass + print("Inner defs should breathe a little.") +def h(): + def inner(): + pass + print("Inner defs should breathe a little.") + + +if os.name == "posix": + import termios + def i_should_be_followed_by_only_one_newline(): + pass +elif os.name == "nt": + try: + import msvcrt + def i_should_be_followed_by_only_one_newline(): + pass + + except ImportError: + + def i_should_be_followed_by_only_one_newline(): + pass + +elif False: + + class IHopeYouAreHavingALovelyDay: + def __call__(self): + print("i_should_be_followed_by_only_one_newline") +else: + + def foo(): + pass + +with hmm_but_this_should_get_two_preceding_newlines(): + pass + +# output + +def f( + a, + **kwargs, +) -> A: + with cache_dir(): + if something: + result = CliRunner().invoke( + black.main, [str(src1), str(src2), "--diff", "--check"] + ) + limited.append(-limited.pop()) # negate top + return A( + very_long_argument_name1=very_long_value_for_the_argument, + very_long_argument_name2=-very.long.value.for_the_argument, + **kwargs, + ) + + +def g(): + "Docstring." + + def inner(): + pass + + print("Inner defs should breathe a little.") + + +def h(): + def inner(): + pass + + print("Inner defs should breathe a little.") + + +if os.name == "posix": + import termios + + def i_should_be_followed_by_only_one_newline(): + pass + +elif os.name == "nt": + try: + import msvcrt + + def i_should_be_followed_by_only_one_newline(): + pass + + except ImportError: + + def i_should_be_followed_by_only_one_newline(): + pass + +elif False: + + class IHopeYouAreHavingALovelyDay: + def __call__(self): + print("i_should_be_followed_by_only_one_newline") + +else: + + def foo(): + pass + + +with hmm_but_this_should_get_two_preceding_newlines(): + pass diff --git a/tests/data/cases/function_trailing_comma.py b/tests/data/cases/function_trailing_comma.py new file mode 100644 index 0000000..63cf399 --- /dev/null +++ b/tests/data/cases/function_trailing_comma.py @@ -0,0 +1,308 @@ +def f(a,): + d = {'key': 'value',} + tup = (1,) + +def f2(a,b,): + d = {'key': 'value', 'key2': 'value2',} + tup = (1,2,) + +def f(a:int=1,): + call(arg={'explode': 'this',}) + call2(arg=[1,2,3],) + x = { + "a": 1, + "b": 2, + }["a"] + if a == {"a": 1,"b": 2,"c": 3,"d": 4,"e": 5,"f": 6,"g": 7,"h": 8,}["a"]: + pass + +def xxxxxxxxxxxxxxxxxxxxxxxxxxxx() -> Set[ + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +]: + json = {"k": {"k2": {"k3": [1,]}}} + + + +# The type annotation shouldn't get a trailing comma since that would change its type. +# Relevant bug report: https://github.com/psf/black/issues/2381. +def some_function_with_a_really_long_name() -> ( + returning_a_deeply_nested_import_of_a_type_i_suppose +): + pass + + +def some_method_with_a_really_long_name(very_long_parameter_so_yeah: str, another_long_parameter: int) -> ( + another_case_of_returning_a_deeply_nested_import_of_a_type_i_suppose_cause_why_not +): + pass + + +def func() -> ( + also_super_long_type_annotation_that_may_cause_an_AST_related_crash_in_black(this_shouldn_t_get_a_trailing_comma_too) +): + pass + + +def func() -> ((also_super_long_type_annotation_that_may_cause_an_AST_related_crash_in_black( + this_shouldn_t_get_a_trailing_comma_too + )) +): + pass + + +# Make sure inner one-element tuple won't explode +some_module.some_function( + argument1, (one_element_tuple,), argument4, argument5, argument6 +) + +# Inner trailing comma causes outer to explode +some_module.some_function( + argument1, (one, two,), argument4, argument5, argument6 +) + +def foo() -> ( + # comment inside parenthesised return type + int +): + ... + +def foo() -> ( + # comment inside parenthesised return type + # more + int + # another +): + ... + +def foo() -> ( + # comment inside parenthesised new union return type + int | str | bytes +): + ... + +def foo() -> ( + # comment inside plain tuple +): + pass + +def foo(arg: (# comment with non-return annotation + int + # comment with non-return annotation +)): + pass + +def foo(arg: (# comment with non-return annotation + int | range | memoryview + # comment with non-return annotation +)): + pass + +def foo(arg: (# only before + int +)): + pass + +def foo(arg: ( + int + # only after +)): + pass + +variable: ( # annotation + because + # why not +) + +variable: ( + because + # why not +) + +# output + +def f( + a, +): + d = { + "key": "value", + } + tup = (1,) + + +def f2( + a, + b, +): + d = { + "key": "value", + "key2": "value2", + } + tup = ( + 1, + 2, + ) + + +def f( + a: int = 1, +): + call( + arg={ + "explode": "this", + } + ) + call2( + arg=[1, 2, 3], + ) + x = { + "a": 1, + "b": 2, + }["a"] + if ( + a + == { + "a": 1, + "b": 2, + "c": 3, + "d": 4, + "e": 5, + "f": 6, + "g": 7, + "h": 8, + }["a"] + ): + pass + + +def xxxxxxxxxxxxxxxxxxxxxxxxxxxx() -> ( + Set["xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"] +): + json = { + "k": { + "k2": { + "k3": [ + 1, + ] + } + } + } + + +# The type annotation shouldn't get a trailing comma since that would change its type. +# Relevant bug report: https://github.com/psf/black/issues/2381. +def some_function_with_a_really_long_name() -> ( + returning_a_deeply_nested_import_of_a_type_i_suppose +): + pass + + +def some_method_with_a_really_long_name( + very_long_parameter_so_yeah: str, another_long_parameter: int +) -> another_case_of_returning_a_deeply_nested_import_of_a_type_i_suppose_cause_why_not: + pass + + +def func() -> ( + also_super_long_type_annotation_that_may_cause_an_AST_related_crash_in_black( + this_shouldn_t_get_a_trailing_comma_too + ) +): + pass + + +def func() -> ( + also_super_long_type_annotation_that_may_cause_an_AST_related_crash_in_black( + this_shouldn_t_get_a_trailing_comma_too + ) +): + pass + + +# Make sure inner one-element tuple won't explode +some_module.some_function( + argument1, (one_element_tuple,), argument4, argument5, argument6 +) + +# Inner trailing comma causes outer to explode +some_module.some_function( + argument1, + ( + one, + two, + ), + argument4, + argument5, + argument6, +) + + +def foo() -> ( + # comment inside parenthesised return type + int +): ... + + +def foo() -> ( + # comment inside parenthesised return type + # more + int + # another +): ... + + +def foo() -> ( + # comment inside parenthesised new union return type + int + | str + | bytes +): ... + + +def foo() -> ( + # comment inside plain tuple +): + pass + + +def foo( + arg: ( # comment with non-return annotation + int + # comment with non-return annotation + ), +): + pass + + +def foo( + arg: ( # comment with non-return annotation + int + | range + | memoryview + # comment with non-return annotation + ), +): + pass + + +def foo(arg: int): # only before + pass + + +def foo( + arg: ( + int + # only after + ), +): + pass + + +variable: ( # annotation + because + # why not +) + +variable: ( + because + # why not +) diff --git a/tests/data/cases/generics_wrapping.py b/tests/data/cases/generics_wrapping.py new file mode 100644 index 0000000..734e2a3 --- /dev/null +++ b/tests/data/cases/generics_wrapping.py @@ -0,0 +1,307 @@ +# flags: --minimum-version=3.12 +def plain[T, B](a: T, b: T) -> T: + return a + +def arg_magic[T, B](a: T, b: T,) -> T: + return a + +def type_param_magic[T, B,](a: T, b: T) -> T: + return a + +def both_magic[T, B,](a: T, b: T,) -> T: + return a + + +def plain_multiline[ + T, + B +]( + a: T, + b: T +) -> T: + return a + +def arg_magic_multiline[ + T, + B +]( + a: T, + b: T, +) -> T: + return a + +def type_param_magic_multiline[ + T, + B, +]( + a: T, + b: T +) -> T: + return a + +def both_magic_multiline[ + T, + B, +]( + a: T, + b: T, +) -> T: + return a + + +def plain_mixed1[ + T, + B +](a: T, b: T) -> T: + return a + +def plain_mixed2[T, B]( + a: T, + b: T +) -> T: + return a + +def arg_magic_mixed1[ + T, + B +](a: T, b: T,) -> T: + return a + +def arg_magic_mixed2[T, B]( + a: T, + b: T, +) -> T: + return a + +def type_param_magic_mixed1[ + T, + B, +](a: T, b: T) -> T: + return a + +def type_param_magic_mixed2[T, B,]( + a: T, + b: T +) -> T: + return a + +def both_magic_mixed1[ + T, + B, +](a: T, b: T,) -> T: + return a + +def both_magic_mixed2[T, B,]( + a: T, + b: T, +) -> T: + return a + +def something_something_function[ + T: Model +](param: list[int], other_param: type[T], *, some_other_param: bool = True) -> QuerySet[ + T +]: + pass + + +def func[A_LOT_OF_GENERIC_TYPES: AreBeingDefinedHere, LIKE_THIS, AND_THIS, ANOTHER_ONE, AND_YET_ANOTHER_ONE: ThisOneHasTyping](a: T, b: T, c: T, d: T, e: T, f: T, g: T, h: T, i: T, j: T, k: T, l: T, m: T, n: T, o: T, p: T) -> T: + return a + + +def with_random_comments[ + Z + # bye +](): + return a + + +def func[ + T, # comment + U # comment + , + Z: # comment + int +](): pass + + +def func[ + T, # comment but it's long so it doesn't just move to the end of the line + U # comment comment comm comm ent ent + , + Z: # comment ent ent comm comm comment + int +](): pass + + +# output +def plain[T, B](a: T, b: T) -> T: + return a + + +def arg_magic[T, B]( + a: T, + b: T, +) -> T: + return a + + +def type_param_magic[ + T, + B, +]( + a: T, b: T +) -> T: + return a + + +def both_magic[ + T, + B, +]( + a: T, + b: T, +) -> T: + return a + + +def plain_multiline[T, B](a: T, b: T) -> T: + return a + + +def arg_magic_multiline[T, B]( + a: T, + b: T, +) -> T: + return a + + +def type_param_magic_multiline[ + T, + B, +]( + a: T, b: T +) -> T: + return a + + +def both_magic_multiline[ + T, + B, +]( + a: T, + b: T, +) -> T: + return a + + +def plain_mixed1[T, B](a: T, b: T) -> T: + return a + + +def plain_mixed2[T, B](a: T, b: T) -> T: + return a + + +def arg_magic_mixed1[T, B]( + a: T, + b: T, +) -> T: + return a + + +def arg_magic_mixed2[T, B]( + a: T, + b: T, +) -> T: + return a + + +def type_param_magic_mixed1[ + T, + B, +]( + a: T, b: T +) -> T: + return a + + +def type_param_magic_mixed2[ + T, + B, +]( + a: T, b: T +) -> T: + return a + + +def both_magic_mixed1[ + T, + B, +]( + a: T, + b: T, +) -> T: + return a + + +def both_magic_mixed2[ + T, + B, +]( + a: T, + b: T, +) -> T: + return a + + +def something_something_function[T: Model]( + param: list[int], other_param: type[T], *, some_other_param: bool = True +) -> QuerySet[T]: + pass + + +def func[ + A_LOT_OF_GENERIC_TYPES: AreBeingDefinedHere, + LIKE_THIS, + AND_THIS, + ANOTHER_ONE, + AND_YET_ANOTHER_ONE: ThisOneHasTyping, +]( + a: T, + b: T, + c: T, + d: T, + e: T, + f: T, + g: T, + h: T, + i: T, + j: T, + k: T, + l: T, + m: T, + n: T, + o: T, + p: T, +) -> T: + return a + + +def with_random_comments[ + Z + # bye +](): + return a + + +def func[T, U, Z: int](): # comment # comment # comment + pass + + +def func[ + T, # comment but it's long so it doesn't just move to the end of the line + U, # comment comment comm comm ent ent + Z: int, # comment ent ent comm comm comment +](): + pass diff --git a/tests/data/cases/if_guard_inside_case.py b/tests/data/cases/if_guard_inside_case.py new file mode 100644 index 0000000..3744699 --- /dev/null +++ b/tests/data/cases/if_guard_inside_case.py @@ -0,0 +1,49 @@ +# flags: --preview + +def f(x): + match x: + # good refactor + case [ + y + ] if y == 123: + pass + + case [ + y + ] if True: + pass + + case [ + y, + ] if True: + pass + + # bad refactor + case [ + y, + ] if y == 123: + pass + + +# output + + +def f(x): + match x: + # good refactor + case [y] if y == 123: + pass + + case [y] if True: + pass + + case [ + y, + ] if True: + pass + + # bad refactor + case [ + y, + ] if y == 123: + pass diff --git a/tests/data/cases/ignore_pyi.py b/tests/data/cases/ignore_pyi.py new file mode 100644 index 0000000..4fae753 --- /dev/null +++ b/tests/data/cases/ignore_pyi.py @@ -0,0 +1,42 @@ +# flags: --pyi +def f(): # type: ignore + ... + +class x: # some comment + ... + +class y: + ... # comment + +# whitespace doesn't matter (note the next line has a trailing space and tab) +class z: + ... + +def g(): + # hi + ... + +def h(): + ... + # bye + +# output + +def f(): # type: ignore + ... + +class x: # some comment + ... + +class y: ... # comment + +# whitespace doesn't matter (note the next line has a trailing space and tab) +class z: ... + +def g(): + # hi + ... + +def h(): + ... + # bye diff --git a/tests/data/cases/import_line_collapse.py b/tests/data/cases/import_line_collapse.py new file mode 100644 index 0000000..2c6c915 --- /dev/null +++ b/tests/data/cases/import_line_collapse.py @@ -0,0 +1,179 @@ +from middleman.authentication import validate_oauth_token + + +logger = logging.getLogger(__name__) + + +# case 2 comment after import +from middleman.authentication import validate_oauth_token +#comment + +logger = logging.getLogger(__name__) + + +# case 3 comment after import +from middleman.authentication import validate_oauth_token +# comment +logger = logging.getLogger(__name__) + + +from middleman.authentication import validate_oauth_token + + + +logger = logging.getLogger(__name__) + + +# case 4 try catch with import after import +import os +import os + + + +try: + import os +except Exception: + pass + +try: + import os + def func(): + a = 1 +except Exception: + pass + + +# case 5 multiple imports +import os +import os + +import os +import os + + + + + +for i in range(10): + print(i) + + +# case 6 import in function +def func(): + print() + import os + def func(): + pass + print() + + +def func(): + import os + a = 1 + print() + + +def func(): + import os + + + a = 1 + print() + + +def func(): + import os + + + + a = 1 + print() + +# output + + +from middleman.authentication import validate_oauth_token + +logger = logging.getLogger(__name__) + + +# case 2 comment after import +from middleman.authentication import validate_oauth_token + +# comment + +logger = logging.getLogger(__name__) + + +# case 3 comment after import +from middleman.authentication import validate_oauth_token + +# comment +logger = logging.getLogger(__name__) + + +from middleman.authentication import validate_oauth_token + +logger = logging.getLogger(__name__) + + +# case 4 try catch with import after import +import os +import os + +try: + import os +except Exception: + pass + +try: + import os + + def func(): + a = 1 + +except Exception: + pass + + +# case 5 multiple imports +import os +import os + +import os +import os + +for i in range(10): + print(i) + + +# case 6 import in function +def func(): + print() + import os + + def func(): + pass + + print() + + +def func(): + import os + + a = 1 + print() + + +def func(): + import os + + a = 1 + print() + + +def func(): + import os + + a = 1 + print() diff --git a/tests/data/cases/import_spacing.py b/tests/data/cases/import_spacing.py new file mode 100644 index 0000000..8e6e23c --- /dev/null +++ b/tests/data/cases/import_spacing.py @@ -0,0 +1,118 @@ +"""The asyncio package, tracking PEP 3156.""" + +# flake8: noqa + +from logging import ( + WARNING +) +from logging import ( + ERROR, +) +import sys + +# This relies on each of the submodules having an __all__ variable. +from .base_events import * +from .coroutines import * +from .events import * # comment here + +from .futures import * +from .locks import * # comment here +from .protocols import * + +from ..runners import * # comment here +from ..queues import * +from ..streams import * + +from some_library import ( + Just, Enough, Libraries, To, Fit, In, This, Nice, Split, Which, We, No, Longer, Use +) +from name_of_a_company.extremely_long_project_name.component.ttypes import CuteLittleServiceHandlerFactoryyy +from name_of_a_company.extremely_long_project_name.extremely_long_component_name.ttypes import * + +from .a.b.c.subprocess import * +from . import (tasks) +from . import (A, B, C) +from . import SomeVeryLongNameAndAllOfItsAdditionalLetters1, \ + SomeVeryLongNameAndAllOfItsAdditionalLetters2 + +__all__ = ( + base_events.__all__ + + coroutines.__all__ + + events.__all__ + + futures.__all__ + + locks.__all__ + + protocols.__all__ + + runners.__all__ + + queues.__all__ + + streams.__all__ + + tasks.__all__ +) + + +# output + + +"""The asyncio package, tracking PEP 3156.""" + +# flake8: noqa + +from logging import WARNING +from logging import ( + ERROR, +) +import sys + +# This relies on each of the submodules having an __all__ variable. +from .base_events import * +from .coroutines import * +from .events import * # comment here + +from .futures import * +from .locks import * # comment here +from .protocols import * + +from ..runners import * # comment here +from ..queues import * +from ..streams import * + +from some_library import ( + Just, + Enough, + Libraries, + To, + Fit, + In, + This, + Nice, + Split, + Which, + We, + No, + Longer, + Use, +) +from name_of_a_company.extremely_long_project_name.component.ttypes import ( + CuteLittleServiceHandlerFactoryyy, +) +from name_of_a_company.extremely_long_project_name.extremely_long_component_name.ttypes import * + +from .a.b.c.subprocess import * +from . import tasks +from . import A, B, C +from . import ( + SomeVeryLongNameAndAllOfItsAdditionalLetters1, + SomeVeryLongNameAndAllOfItsAdditionalLetters2, +) + +__all__ = ( + base_events.__all__ + + coroutines.__all__ + + events.__all__ + + futures.__all__ + + locks.__all__ + + protocols.__all__ + + runners.__all__ + + queues.__all__ + + streams.__all__ + + tasks.__all__ +) diff --git a/tests/data/cases/is_simple_lookup_for_doublestar_expression.py b/tests/data/cases/is_simple_lookup_for_doublestar_expression.py new file mode 100644 index 0000000..ae3643b --- /dev/null +++ b/tests/data/cases/is_simple_lookup_for_doublestar_expression.py @@ -0,0 +1,13 @@ +m2 = None if not isinstance(dist, Normal) else m** 2 + s * 2 +m3 = None if not isinstance(dist, Normal) else m ** 2 + s * 2 +m4 = None if not isinstance(dist, Normal) else m**2 + s * 2 +m5 = obj.method(another_obj.method()).attribute **2 +m6 = None if ... else m**2 + s**2 + + +# output +m2 = None if not isinstance(dist, Normal) else m**2 + s * 2 +m3 = None if not isinstance(dist, Normal) else m**2 + s * 2 +m4 = None if not isinstance(dist, Normal) else m**2 + s * 2 +m5 = obj.method(another_obj.method()).attribute ** 2 +m6 = None if ... else m**2 + s**2 \ No newline at end of file diff --git a/tests/data/cases/jupytext_markdown_fmt.py b/tests/data/cases/jupytext_markdown_fmt.py new file mode 100644 index 0000000..43e9463 --- /dev/null +++ b/tests/data/cases/jupytext_markdown_fmt.py @@ -0,0 +1,24 @@ +# Test that Jupytext markdown comments are preserved before fmt:off/on blocks +# %% [markdown] + +# fmt: off +# fmt: on + +# Also test with other comments +# Some comment +# %% [markdown] +# Another comment + +# fmt: off +x = 1 +# fmt: on + +# Test multiple markdown comments +# %% [markdown] +# First markdown +# %% [code] +# Code cell + +# fmt: off +y = 2 +# fmt: on \ No newline at end of file diff --git a/tests/data/cases/keep_newline_after_match.py b/tests/data/cases/keep_newline_after_match.py new file mode 100644 index 0000000..dbeccce --- /dev/null +++ b/tests/data/cases/keep_newline_after_match.py @@ -0,0 +1,41 @@ +# flags: --minimum-version=3.10 +def http_status(status): + + match status: + + case 400: + + return "Bad request" + + case 401: + + return "Unauthorized" + + case 403: + + return "Forbidden" + + case 404: + + return "Not found" + +# output +def http_status(status): + + match status: + + case 400: + + return "Bad request" + + case 401: + + return "Unauthorized" + + case 403: + + return "Forbidden" + + case 404: + + return "Not found" \ No newline at end of file diff --git a/tests/data/cases/line_ranges_basic.py b/tests/data/cases/line_ranges_basic.py new file mode 100644 index 0000000..9f0fb2d --- /dev/null +++ b/tests/data/cases/line_ranges_basic.py @@ -0,0 +1,107 @@ +# flags: --line-ranges=5-6 +# NOTE: If you need to modify this file, pay special attention to the --line-ranges= +# flag above as it's formatting specifically these lines. +def foo1(parameter_1, parameter_2, parameter_3, parameter_4, parameter_5, parameter_6, parameter_7): pass +def foo2(parameter_1, parameter_2, parameter_3, parameter_4, parameter_5, parameter_6, parameter_7): pass +def foo3(parameter_1, parameter_2, parameter_3, parameter_4, parameter_5, parameter_6, parameter_7): pass +def foo4(parameter_1, parameter_2, parameter_3, parameter_4, parameter_5, parameter_6, parameter_7): pass + +# Adding some unformated code covering a wide range of syntaxes. + +if True: + # Incorrectly indented prefix comments. + pass + +import typing +from typing import ( + Any , + ) +class MyClass( object): # Trailing comment with extra leading space. + #NOTE: The following indentation is incorrect: + @decor( 1 * 3 ) + def my_func( arg): + pass + +try: # Trailing comment with extra leading space. + for i in range(10): # Trailing comment with extra leading space. + while condition: + if something: + then_something( ) + elif something_else: + then_something_else( ) +except ValueError as e: + unformatted( ) +finally: + unformatted( ) + +async def test_async_unformatted( ): # Trailing comment with extra leading space. + async for i in some_iter( unformatted ): # Trailing comment with extra leading space. + await asyncio.sleep( 1 ) + async with some_context( unformatted ): + print( "unformatted" ) + + +# output +# flags: --line-ranges=5-6 +# NOTE: If you need to modify this file, pay special attention to the --line-ranges= +# flag above as it's formatting specifically these lines. +def foo1(parameter_1, parameter_2, parameter_3, parameter_4, parameter_5, parameter_6, parameter_7): pass +def foo2( + parameter_1, + parameter_2, + parameter_3, + parameter_4, + parameter_5, + parameter_6, + parameter_7, +): + pass + + +def foo3( + parameter_1, + parameter_2, + parameter_3, + parameter_4, + parameter_5, + parameter_6, + parameter_7, +): + pass + + +def foo4(parameter_1, parameter_2, parameter_3, parameter_4, parameter_5, parameter_6, parameter_7): pass + +# Adding some unformated code covering a wide range of syntaxes. + +if True: + # Incorrectly indented prefix comments. + pass + +import typing +from typing import ( + Any , + ) +class MyClass( object): # Trailing comment with extra leading space. + #NOTE: The following indentation is incorrect: + @decor( 1 * 3 ) + def my_func( arg): + pass + +try: # Trailing comment with extra leading space. + for i in range(10): # Trailing comment with extra leading space. + while condition: + if something: + then_something( ) + elif something_else: + then_something_else( ) +except ValueError as e: + unformatted( ) +finally: + unformatted( ) + +async def test_async_unformatted( ): # Trailing comment with extra leading space. + async for i in some_iter( unformatted ): # Trailing comment with extra leading space. + await asyncio.sleep( 1 ) + async with some_context( unformatted ): + print( "unformatted" ) diff --git a/tests/data/cases/line_ranges_decorator_edge_case.py b/tests/data/cases/line_ranges_decorator_edge_case.py new file mode 100644 index 0000000..483fbe8 --- /dev/null +++ b/tests/data/cases/line_ranges_decorator_edge_case.py @@ -0,0 +1,8 @@ +# flags: --line-ranges=6-7 +class Foo: + + @overload + def foo(): ... + + def fox(self): + print() diff --git a/tests/data/cases/line_ranges_diff_edge_case.py b/tests/data/cases/line_ranges_diff_edge_case.py new file mode 100644 index 0000000..f5cb2d0 --- /dev/null +++ b/tests/data/cases/line_ranges_diff_edge_case.py @@ -0,0 +1,28 @@ +# flags: --line-ranges=10-11 +# NOTE: If you need to modify this file, pay special attention to the --line-ranges= +# flag above as it's formatting specifically these lines. + +# Reproducible example for https://github.com/psf/black/issues/4033. +# This can be fixed in the future if we use a better diffing algorithm, or make Black +# perform formatting in a single pass. + +print ( "format me" ) +print ( "format me" ) +print ( "format me" ) +print ( "format me" ) +print ( "format me" ) + +# output +# flags: --line-ranges=10-11 +# NOTE: If you need to modify this file, pay special attention to the --line-ranges= +# flag above as it's formatting specifically these lines. + +# Reproducible example for https://github.com/psf/black/issues/4033. +# This can be fixed in the future if we use a better diffing algorithm, or make Black +# perform formatting in a single pass. + +print ( "format me" ) +print("format me") +print("format me") +print("format me") +print("format me") diff --git a/tests/data/cases/line_ranges_exceeding_end.py b/tests/data/cases/line_ranges_exceeding_end.py new file mode 100644 index 0000000..8f17491 --- /dev/null +++ b/tests/data/cases/line_ranges_exceeding_end.py @@ -0,0 +1,36 @@ +# flags: --line-ranges=6-1000 +# NOTE: If you need to modify this file, pay special attention to the --line-ranges= +# flag above as it's formatting specifically these lines. +def foo1(parameter_1, parameter_2, parameter_3, parameter_4, parameter_5, parameter_6, parameter_7): pass +def foo2(parameter_1, parameter_2, parameter_3, parameter_4, parameter_5, parameter_6, parameter_7): pass +def foo3(parameter_1, parameter_2, parameter_3, parameter_4, parameter_5, parameter_6, parameter_7): pass +def foo4(parameter_1, parameter_2, parameter_3, parameter_4, parameter_5, parameter_6, parameter_7): pass + +# output +# flags: --line-ranges=6-1000 +# NOTE: If you need to modify this file, pay special attention to the --line-ranges= +# flag above as it's formatting specifically these lines. +def foo1(parameter_1, parameter_2, parameter_3, parameter_4, parameter_5, parameter_6, parameter_7): pass +def foo2(parameter_1, parameter_2, parameter_3, parameter_4, parameter_5, parameter_6, parameter_7): pass +def foo3( + parameter_1, + parameter_2, + parameter_3, + parameter_4, + parameter_5, + parameter_6, + parameter_7, +): + pass + + +def foo4( + parameter_1, + parameter_2, + parameter_3, + parameter_4, + parameter_5, + parameter_6, + parameter_7, +): + pass diff --git a/tests/data/cases/line_ranges_fmt_off.py b/tests/data/cases/line_ranges_fmt_off.py new file mode 100644 index 0000000..b51cef5 --- /dev/null +++ b/tests/data/cases/line_ranges_fmt_off.py @@ -0,0 +1,49 @@ +# flags: --line-ranges=7-7 --line-ranges=17-23 +# NOTE: If you need to modify this file, pay special attention to the --line-ranges= +# flag above as it's formatting specifically these lines. + +# fmt: off +import os +def myfunc( ): # Intentionally unformatted. + pass +# fmt: on + + +def myfunc( ): # This will not be reformatted. + print( {"also won't be reformatted"} ) +# fmt: off +def myfunc( ): # This will not be reformatted. + print( {"also won't be reformatted"} ) +def myfunc( ): # This will not be reformatted. + print( {"also won't be reformatted"} ) +# fmt: on + + +def myfunc( ): # This will be reformatted. + print( {"this will be reformatted"} ) + +# output + +# flags: --line-ranges=7-7 --line-ranges=17-23 +# NOTE: If you need to modify this file, pay special attention to the --line-ranges= +# flag above as it's formatting specifically these lines. + +# fmt: off +import os +def myfunc( ): # Intentionally unformatted. + pass +# fmt: on + + +def myfunc( ): # This will not be reformatted. + print( {"also won't be reformatted"} ) +# fmt: off +def myfunc( ): # This will not be reformatted. + print( {"also won't be reformatted"} ) +def myfunc( ): # This will not be reformatted. + print( {"also won't be reformatted"} ) +# fmt: on + + +def myfunc(): # This will be reformatted. + print({"this will be reformatted"}) diff --git a/tests/data/cases/line_ranges_fmt_off_decorator.py b/tests/data/cases/line_ranges_fmt_off_decorator.py new file mode 100644 index 0000000..065bf43 --- /dev/null +++ b/tests/data/cases/line_ranges_fmt_off_decorator.py @@ -0,0 +1,47 @@ +# flags: --line-ranges=12-12 --line-ranges=21-21 +# NOTE: If you need to modify this file, pay special attention to the --line-ranges= +# flag above as it's formatting specifically these lines. + +# Regression test for an edge case involving decorators and fmt: off/on. +class MyClass: + + # fmt: off + @decorator ( ) + # fmt: on + def method(): + print ( "str" ) + + @decor( + a=1, + # fmt: off + b=(2, 3), + # fmt: on + ) + def func(): + pass + + +# output + +# flags: --line-ranges=12-12 --line-ranges=21-21 +# NOTE: If you need to modify this file, pay special attention to the --line-ranges= +# flag above as it's formatting specifically these lines. + +# Regression test for an edge case involving decorators and fmt: off/on. +class MyClass: + + # fmt: off + @decorator ( ) + # fmt: on + def method(): + print("str") + + @decor( + a=1, + # fmt: off + b=(2, 3), + # fmt: on + ) + def func(): + pass + diff --git a/tests/data/cases/line_ranges_fmt_off_overlap.py b/tests/data/cases/line_ranges_fmt_off_overlap.py new file mode 100644 index 0000000..0391d17 --- /dev/null +++ b/tests/data/cases/line_ranges_fmt_off_overlap.py @@ -0,0 +1,37 @@ +# flags: --line-ranges=11-17 +# NOTE: If you need to modify this file, pay special attention to the --line-ranges= +# flag above as it's formatting specifically these lines. + + +def myfunc( ): # This will not be reformatted. + print( {"also won't be reformatted"} ) +# fmt: off +def myfunc( ): # This will not be reformatted. + print( {"also won't be reformatted"} ) +def myfunc( ): # This will not be reformatted. + print( {"also won't be reformatted"} ) +# fmt: on + + +def myfunc( ): # This will be reformatted. + print( {"this will be reformatted"} ) + +# output + +# flags: --line-ranges=11-17 +# NOTE: If you need to modify this file, pay special attention to the --line-ranges= +# flag above as it's formatting specifically these lines. + + +def myfunc( ): # This will not be reformatted. + print( {"also won't be reformatted"} ) +# fmt: off +def myfunc( ): # This will not be reformatted. + print( {"also won't be reformatted"} ) +def myfunc( ): # This will not be reformatted. + print( {"also won't be reformatted"} ) +# fmt: on + + +def myfunc(): # This will be reformatted. + print({"this will be reformatted"}) diff --git a/tests/data/cases/line_ranges_imports.py b/tests/data/cases/line_ranges_imports.py new file mode 100644 index 0000000..76b18ff --- /dev/null +++ b/tests/data/cases/line_ranges_imports.py @@ -0,0 +1,9 @@ +# flags: --line-ranges=8-8 +# NOTE: If you need to modify this file, pay special attention to the --line-ranges= +# flag above as it's formatting specifically these lines. + +# This test ensures no empty lines are added around import lines. +# It caused an issue before https://github.com/psf/black/pull/3610 is merged. +import os +import re +import sys diff --git a/tests/data/cases/line_ranges_indentation.py b/tests/data/cases/line_ranges_indentation.py new file mode 100644 index 0000000..82d3ad6 --- /dev/null +++ b/tests/data/cases/line_ranges_indentation.py @@ -0,0 +1,27 @@ +# flags: --line-ranges=5-5 +# NOTE: If you need to modify this file, pay special attention to the --line-ranges= +# flag above as it's formatting specifically these lines. +if cond1: + print("first") + if cond2: + print("second") + else: + print("else") + +if another_cond: + print("will not be changed") + +# output + +# flags: --line-ranges=5-5 +# NOTE: If you need to modify this file, pay special attention to the --line-ranges= +# flag above as it's formatting specifically these lines. +if cond1: + print("first") + if cond2: + print("second") + else: + print("else") + +if another_cond: + print("will not be changed") diff --git a/tests/data/cases/line_ranges_outside_source.py b/tests/data/cases/line_ranges_outside_source.py new file mode 100644 index 0000000..edec901 --- /dev/null +++ b/tests/data/cases/line_ranges_outside_source.py @@ -0,0 +1,7 @@ +# flags: --line-ranges=5000-6000 +# NOTE: If you need to modify this file, pay special attention to the --line-ranges= +# flag above as it's formatting specifically these lines, in this case none. +def foo1(parameter_1, parameter_2, parameter_3, parameter_4, parameter_5, parameter_6, parameter_7): pass +def foo2(parameter_1, parameter_2, parameter_3, parameter_4, parameter_5, parameter_6, parameter_7): pass +def foo3(parameter_1, parameter_2, parameter_3, parameter_4, parameter_5, parameter_6, parameter_7): pass +def foo4(parameter_1, parameter_2, parameter_3, parameter_4, parameter_5, parameter_6, parameter_7): pass diff --git a/tests/data/cases/line_ranges_two_passes.py b/tests/data/cases/line_ranges_two_passes.py new file mode 100644 index 0000000..aeed326 --- /dev/null +++ b/tests/data/cases/line_ranges_two_passes.py @@ -0,0 +1,27 @@ +# flags: --line-ranges=9-11 +# NOTE: If you need to modify this file, pay special attention to the --line-ranges= +# flag above as it's formatting specifically these lines. + +# This is a specific case for Black's two-pass formatting behavior in `format_str`. +# The second pass must respect the line ranges before the first pass. + + +def restrict_to_this_line(arg1, + arg2, + arg3): + print ( "This should not be formatted." ) + print ( "Note that in the second pass, the original line range 9-11 will cover these print lines.") + +# output + +# flags: --line-ranges=9-11 +# NOTE: If you need to modify this file, pay special attention to the --line-ranges= +# flag above as it's formatting specifically these lines. + +# This is a specific case for Black's two-pass formatting behavior in `format_str`. +# The second pass must respect the line ranges before the first pass. + + +def restrict_to_this_line(arg1, arg2, arg3): + print ( "This should not be formatted." ) + print ( "Note that in the second pass, the original line range 9-11 will cover these print lines.") diff --git a/tests/data/cases/line_ranges_unwrapping.py b/tests/data/cases/line_ranges_unwrapping.py new file mode 100644 index 0000000..cd7751b --- /dev/null +++ b/tests/data/cases/line_ranges_unwrapping.py @@ -0,0 +1,25 @@ +# flags: --line-ranges=5-5 --line-ranges=9-9 --line-ranges=13-13 +# NOTE: If you need to modify this file, pay special attention to the --line-ranges= +# flag above as it's formatting specifically these lines. +alist = [ + 1, 2 +] + +adict = { + "key" : "value" +} + +func_call ( + arg = value +) + +# output + +# flags: --line-ranges=5-5 --line-ranges=9-9 --line-ranges=13-13 +# NOTE: If you need to modify this file, pay special attention to the --line-ranges= +# flag above as it's formatting specifically these lines. +alist = [1, 2] + +adict = {"key": "value"} + +func_call(arg=value) diff --git a/tests/data/cases/linelength6.py b/tests/data/cases/linelength6.py new file mode 100644 index 0000000..158038b --- /dev/null +++ b/tests/data/cases/linelength6.py @@ -0,0 +1,6 @@ +# flags: --line-length=6 +# Regression test for #3427, which reproes only with line length <= 6 +def f(): + """ + x + """ diff --git a/tests/data/cases/long_strings__type_annotations.py b/tests/data/cases/long_strings__type_annotations.py new file mode 100644 index 0000000..45de882 --- /dev/null +++ b/tests/data/cases/long_strings__type_annotations.py @@ -0,0 +1,59 @@ +def func( + arg1, + arg2, +) -> Set["this_is_a_very_long_module_name.AndAVeryLongClasName" + ".WithAVeryVeryVeryVeryVeryLongSubClassName"]: + pass + + +def func( + argument: ( + "VeryLongClassNameWithAwkwardGenericSubtype[int] |" + "VeryLongClassNameWithAwkwardGenericSubtype[str]" + ), +) -> ( + "VeryLongClassNameWithAwkwardGenericSubtype[int] |" + "VeryLongClassNameWithAwkwardGenericSubtype[str]" +): + pass + + +def func( + argument: ( + "int |" + "str" + ), +) -> Set["int |" + " str"]: + pass + + +# output + + +def func( + arg1, + arg2, +) -> Set[ + "this_is_a_very_long_module_name.AndAVeryLongClasName" + ".WithAVeryVeryVeryVeryVeryLongSubClassName" +]: + pass + + +def func( + argument: ( + "VeryLongClassNameWithAwkwardGenericSubtype[int] |" + "VeryLongClassNameWithAwkwardGenericSubtype[str]" + ), +) -> ( + "VeryLongClassNameWithAwkwardGenericSubtype[int] |" + "VeryLongClassNameWithAwkwardGenericSubtype[str]" +): + pass + + +def func( + argument: "int |" "str", +) -> Set["int |" " str"]: + pass diff --git a/tests/data/cases/long_strings_flag_disabled.py b/tests/data/cases/long_strings_flag_disabled.py new file mode 100644 index 0000000..d81c331 --- /dev/null +++ b/tests/data/cases/long_strings_flag_disabled.py @@ -0,0 +1,296 @@ +x = "This is a really long string that can't possibly be expected to fit all together on one line. In fact it may even take up three or more lines... like four or five... but probably just three." + +x += "This is a really long string that can't possibly be expected to fit all together on one line. In fact it may even take up three or more lines... like four or five... but probably just three." + +y = "Short string" + +print( + "This is a really long string inside of a print statement with extra arguments attached at the end of it.", + x, + y, + z, +) + +print( + "This is a really long string inside of a print statement with no extra arguments attached at the end of it." +) + +D1 = { + "The First": "This is a really long string that can't possibly be expected to fit all together on one line. Also it is inside a dictionary, so formatting is more difficult.", + "The Second": "This is another really really (not really) long string that also can't be expected to fit on one line and is, like the other string, inside a dictionary.", +} + +D2 = { + 1.0: "This is a really long string that can't possibly be expected to fit all together on one line. Also it is inside a dictionary, so formatting is more difficult.", + 2.0: "This is another really really (not really) long string that also can't be expected to fit on one line and is, like the other string, inside a dictionary.", +} + +D3 = { + x: "This is a really long string that can't possibly be expected to fit all together on one line. Also it is inside a dictionary, so formatting is more difficult.", + y: "This is another really really (not really) long string that also can't be expected to fit on one line and is, like the other string, inside a dictionary.", +} + +D4 = { + "A long and ridiculous {}".format( + string_key + ): "This is a really really really long string that has to go i,side of a dictionary. It is soooo bad.", + some_func( + "calling", "some", "stuff" + ): "This is a really really really long string that has to go inside of a dictionary. It is {soooo} bad (#{x}).".format( + sooo="soooo", x=2 + ), + "A %s %s" + % ( + "formatted", + "string", + ): ( + "This is a really really really long string that has to go inside of a dictionary. It is %s bad (#%d)." + % ("soooo", 2) + ), +} + +func_with_keywords( + my_arg, + my_kwarg="Long keyword strings also need to be wrapped, but they will probably need to be handled a little bit differently.", +) + +bad_split1 = ( + "But what should happen when code has already been formatted but in the wrong way? Like" + " with a space at the end instead of the beginning. Or what about when it is split too soon?" +) + +bad_split2 = ( + "But what should happen when code has already " + "been formatted but in the wrong way? Like " + "with a space at the end instead of the " + "beginning. Or what about when it is split too " + "soon? In the case of a split that is too " + "short, black will try to honer the custom " + "split." +) + +bad_split3 = ( + "What if we have inline comments on " # First Comment + "each line of a bad split? In that " # Second Comment + "case, we should just leave it alone." # Third Comment +) + +bad_split_func1( + "But what should happen when code has already " + "been formatted but in the wrong way? Like " + "with a space at the end instead of the " + "beginning. Or what about when it is split too " + "soon? In the case of a split that is too " + "short, black will try to honer the custom " + "split.", + xxx, + yyy, + zzz, +) + +bad_split_func2( + xxx, + yyy, + zzz, + long_string_kwarg="But what should happen when code has already been formatted but in the wrong way? Like " + "with a space at the end instead of the beginning. Or what about when it is split too " + "soon?", +) + +bad_split_func3( + ( + "But what should happen when code has already " + r"been formatted but in the wrong way? Like " + "with a space at the end instead of the " + r"beginning. Or what about when it is split too " + r"soon? In the case of a split that is too " + "short, black will try to honer the custom " + "split." + ), + xxx, + yyy, + zzz, +) + +raw_string = r"This is a long raw string. When re-formatting this string, black needs to make sure it prepends the 'r' onto the new string." + +fmt_string1 = "We also need to be sure to preserve any and all {} which may or may not be attached to the string in question.".format( + "method calls" +) + +fmt_string2 = "But what about when the string is {} but {}".format( + "short", + "the method call is really really really really really really really really long?", +) + +old_fmt_string1 = ( + "While we are on the topic of %s, we should also note that old-style formatting must also be preserved, since some %s still uses it." + % ("formatting", "code") +) + +old_fmt_string2 = "This is a %s %s %s %s" % ( + "really really really really really", + "old", + "way to format strings!", + "Use f-strings instead!", +) + +old_fmt_string3 = ( + "Whereas only the strings after the percent sign were long in the last example, this example uses a long initial string as well. This is another %s %s %s %s" + % ( + "really really really really really", + "old", + "way to format strings!", + "Use f-strings instead!", + ) +) + +fstring = f"f-strings definitely make things more {difficult} than they need to be for {{black}}. But boy they sure are handy. The problem is that some lines will need to have the 'f' whereas others do not. This {line}, for example, needs one." + +fstring_with_no_fexprs = f"Some regular string that needs to get split certainly but is NOT an fstring by any means whatsoever." + +comment_string = "Long lines with inline comments should have their comments appended to the reformatted string's enclosing right parentheses." # This comment gets thrown to the top. + +arg_comment_string = print( + "Long lines with inline comments which are apart of (and not the only member of) an argument list should have their comments appended to the reformatted string's enclosing left parentheses.", # This comment stays on the bottom. + "Arg #2", + "Arg #3", + "Arg #4", + "Arg #5", +) + +pragma_comment_string1 = "Lines which end with an inline pragma comment of the form `# : <...>` should be left alone." # noqa: E501 + +pragma_comment_string2 = "Lines which end with an inline pragma comment of the form `# : <...>` should be left alone." # noqa + +"""This is a really really really long triple quote string and it should not be touched.""" + +triple_quote_string = """This is a really really really long triple quote string assignment and it should not be touched.""" + +assert ( + some_type_of_boolean_expression +), "Followed by a really really really long string that is used to provide context to the AssertionError exception." + +assert ( + some_type_of_boolean_expression +), "Followed by a really really really long string that is used to provide context to the AssertionError exception, which uses dynamic string {}.".format( + "formatting" +) + +assert some_type_of_boolean_expression, ( + "Followed by a really really really long string that is used to provide context to the AssertionError exception, which uses dynamic string %s." + % "formatting" +) + +assert some_type_of_boolean_expression, ( + "Followed by a really really really long string that is used to provide context to the AssertionError exception, which uses dynamic %s %s." + % ("string", "formatting") +) + +some_function_call( + "With a reallly generic name and with a really really long string that is, at some point down the line, " + + added + + " to a variable and then added to another string." +) + +some_function_call( + "With a reallly generic name and with a really really long string that is, at some point down the line, " + + added + + " to a variable and then added to another string. But then what happens when the final string is also supppppperrrrr long?! Well then that second (realllllllly long) string should be split too.", + "and a second argument", + and_a_third, +) + +return "A really really really really really really really really really really really really really long {} {}".format( + "return", "value" +) + +func_with_bad_comma( + "This is a really long string argument to a function that has a trailing comma which should NOT be there.", +) + +func_with_bad_comma( + "This is a really long string argument to a function that has a trailing comma which should NOT be there.", # comment after comma +) + +func_with_bad_comma( + ( + "This is a really long string argument to a function that has a trailing comma" + " which should NOT be there." + ), +) + +func_with_bad_comma( + ( + "This is a really long string argument to a function that has a trailing comma" + " which should NOT be there." + ), # comment after comma +) + +func_with_bad_parens_that_wont_fit_in_one_line( + ("short string that should have parens stripped"), x, y, z +) + +func_with_bad_parens_that_wont_fit_in_one_line( + x, y, ("short string that should have parens stripped"), z +) + +func_with_bad_parens( + ("short string that should have parens stripped"), + x, + y, + z, +) + +func_with_bad_parens( + x, + y, + ("short string that should have parens stripped"), + z, +) + +annotated_variable: Final = ( + "This is a large " + + STRING + + " that has been " + + CONCATENATED + + "using the '+' operator." +) +annotated_variable: Final = ( + "This is a large string that has a type annotation attached to it. A type annotation should NOT stop a long string from being wrapped." +) +annotated_variable: Literal["fakse_literal"] = ( + "This is a large string that has a type annotation attached to it. A type annotation should NOT stop a long string from being wrapped." +) + +backslashes = "This is a really long string with \"embedded\" double quotes and 'single' quotes that also handles checking for an even number of backslashes \\" +backslashes = "This is a really long string with \"embedded\" double quotes and 'single' quotes that also handles checking for an even number of backslashes \\\\" +backslashes = "This is a really 'long' string with \"embedded double quotes\" and 'single' quotes that also handles checking for an odd number of backslashes \\\", like this...\\\\\\" + +short_string = "Hi" " there." + +func_call(short_string=("Hi" " there.")) + +raw_strings = r"Don't" " get" r" merged" " unless they are all raw." + + +def foo(): + yield "This is a really long string that can't possibly be expected to fit all together on one line. In fact it may even take up three or more lines... like four or five... but probably just three." + + +x = f"This is a {{really}} long string that needs to be split without a doubt (i.e. most definitely). In short, this {string} that can't possibly be {{expected}} to fit all together on one line. In {fact} it may even take up three or more lines... like four or five... but probably just four." + +long_unmergable_string_with_pragma = ( + "This is a really long string that can't be merged because it has a likely pragma at the end" # type: ignore + " of it." +) + +long_unmergable_string_with_pragma = ( + "This is a really long string that can't be merged because it has a likely pragma at the end" # noqa + " of it." +) + +long_unmergable_string_with_pragma = ( + "This is a really long string that can't be merged because it has a likely pragma at the end" # pylint: disable=some-pylint-check + " of it." +) diff --git a/tests/data/cases/module_docstring_1.py b/tests/data/cases/module_docstring_1.py new file mode 100644 index 0000000..5751154 --- /dev/null +++ b/tests/data/cases/module_docstring_1.py @@ -0,0 +1,25 @@ +"""Single line module-level docstring should be followed by single newline.""" + + + + +a = 1 + + +"""I'm just a string so should be followed by 2 newlines.""" + + + + +b = 2 + +# output +"""Single line module-level docstring should be followed by single newline.""" + +a = 1 + + +"""I'm just a string so should be followed by 2 newlines.""" + + +b = 2 diff --git a/tests/data/cases/module_docstring_2.py b/tests/data/cases/module_docstring_2.py new file mode 100644 index 0000000..b1d0aaf --- /dev/null +++ b/tests/data/cases/module_docstring_2.py @@ -0,0 +1,69 @@ +"""I am a very helpful module docstring. + +With trailing spaces: +Lorem ipsum dolor sit amet, consectetur adipiscing elit, +sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. +Ut enim ad minim veniam, +quis nostrud exercitation ullamco laboris +nisi ut aliquip ex ea commodo consequat. +Duis aute irure dolor in reprehenderit in voluptate +velit esse cillum dolore eu fugiat nulla pariatur. +Excepteur sint occaecat cupidatat non proident, +sunt in culpa qui officia deserunt mollit anim id est laborum. +""" + + + + +a = 1 + + +"""Look at me I'm a docstring... + +............................................................ +............................................................ +............................................................ +............................................................ +............................................................ +............................................................ +............................................................ +........................................................NOT! +""" + + + + +b = 2 + +# output +"""I am a very helpful module docstring. + +With trailing spaces: +Lorem ipsum dolor sit amet, consectetur adipiscing elit, +sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. +Ut enim ad minim veniam, +quis nostrud exercitation ullamco laboris +nisi ut aliquip ex ea commodo consequat. +Duis aute irure dolor in reprehenderit in voluptate +velit esse cillum dolore eu fugiat nulla pariatur. +Excepteur sint occaecat cupidatat non proident, +sunt in culpa qui officia deserunt mollit anim id est laborum. +""" + +a = 1 + + +"""Look at me I'm a docstring... + +............................................................ +............................................................ +............................................................ +............................................................ +............................................................ +............................................................ +............................................................ +........................................................NOT! +""" + + +b = 2 diff --git a/tests/data/cases/module_docstring_3.py b/tests/data/cases/module_docstring_3.py new file mode 100644 index 0000000..3d0058d --- /dev/null +++ b/tests/data/cases/module_docstring_3.py @@ -0,0 +1,7 @@ +"""Single line module-level docstring should be followed by single newline.""" +a = 1 + +# output +"""Single line module-level docstring should be followed by single newline.""" + +a = 1 diff --git a/tests/data/cases/module_docstring_4.py b/tests/data/cases/module_docstring_4.py new file mode 100644 index 0000000..b172007 --- /dev/null +++ b/tests/data/cases/module_docstring_4.py @@ -0,0 +1,8 @@ +"""Single line module-level docstring should be followed by single newline.""" + +a = 1 + +# output +"""Single line module-level docstring should be followed by single newline.""" + +a = 1 diff --git a/tests/data/cases/module_docstring_after_comment.py b/tests/data/cases/module_docstring_after_comment.py new file mode 100644 index 0000000..5709b92 --- /dev/null +++ b/tests/data/cases/module_docstring_after_comment.py @@ -0,0 +1,21 @@ +#!/python + +# regression test for #4762 +""" +docstring +""" +from __future__ import annotations + +import os + +# output +#!/python + +# regression test for #4762 +""" +docstring +""" + +from __future__ import annotations + +import os diff --git a/tests/data/cases/module_docstring_followed_by_class.py b/tests/data/cases/module_docstring_followed_by_class.py new file mode 100644 index 0000000..c291e61 --- /dev/null +++ b/tests/data/cases/module_docstring_followed_by_class.py @@ -0,0 +1,10 @@ +"""Two blank lines between module docstring and a class.""" +class MyClass: + pass + +# output +"""Two blank lines between module docstring and a class.""" + + +class MyClass: + pass diff --git a/tests/data/cases/module_docstring_followed_by_function.py b/tests/data/cases/module_docstring_followed_by_function.py new file mode 100644 index 0000000..fd29b98 --- /dev/null +++ b/tests/data/cases/module_docstring_followed_by_function.py @@ -0,0 +1,10 @@ +"""Two blank lines between module docstring and a function def.""" +def function(): + pass + +# output +"""Two blank lines between module docstring and a function def.""" + + +def function(): + pass diff --git a/tests/data/cases/multiline_consecutive_open_parentheses_ignore.py b/tests/data/cases/multiline_consecutive_open_parentheses_ignore.py new file mode 100644 index 0000000..6ec8bb4 --- /dev/null +++ b/tests/data/cases/multiline_consecutive_open_parentheses_ignore.py @@ -0,0 +1,41 @@ +# This is a regression test. Issue #3737 + +a = ( # type: ignore + int( # type: ignore + int( # type: ignore + int( # type: ignore + 6 + ) + ) + ) +) + +b = ( + int( + 6 + ) +) + +print( "111") # type: ignore +print( "111" ) # type: ignore +print( "111" ) # type: ignore + + +# output + + +# This is a regression test. Issue #3737 + +a = ( # type: ignore + int( # type: ignore + int( # type: ignore + int(6) # type: ignore + ) + ) +) + +b = int(6) + +print("111") # type: ignore +print("111") # type: ignore +print("111") # type: ignore \ No newline at end of file diff --git a/tests/data/cases/multiline_strings.py b/tests/data/cases/multiline_strings.py new file mode 100644 index 0000000..10662d8 --- /dev/null +++ b/tests/data/cases/multiline_strings.py @@ -0,0 +1,539 @@ +"""cow +say""", +call(3, "dogsay", textwrap.dedent("""dove + coo""" % "cowabunga")) +call(3, "dogsay", textwrap.dedent("""dove +coo""" % "cowabunga")) +call(3, textwrap.dedent("""cow + moo""" % "cowabunga"), "dogsay") +call(3, "dogsay", textwrap.dedent("""crow + caw""" % "cowabunga"),) +call(3, textwrap.dedent("""cat + meow""" % "cowabunga"), {"dog", "say"}) +call(3, {"dog", "say"}, textwrap.dedent("""horse + neigh""" % "cowabunga")) +call(3, {"dog", "say"}, textwrap.dedent("""pig + oink""" % "cowabunga"),) +textwrap.dedent("""A one-line triple-quoted string.""") +textwrap.dedent("""A two-line triple-quoted string +since it goes to the next line.""") +textwrap.dedent("""A three-line triple-quoted string +that not only goes to the next line +but also goes one line beyond.""") +textwrap.dedent("""\ + A triple-quoted string + actually leveraging the textwrap.dedent functionality + that ends in a trailing newline, + representing e.g. file contents. +""") +path.write_text(textwrap.dedent("""\ + A triple-quoted string + actually leveraging the textwrap.dedent functionality + that ends in a trailing newline, + representing e.g. file contents. +""")) +path.write_text(textwrap.dedent("""\ + A triple-quoted string + actually leveraging the textwrap.dedent functionality + that ends in a trailing newline, + representing e.g. {config_filename} file contents. +""".format("config_filename", config_filename))) +# Another use case +data = yaml.load("""\ +a: 1 +b: 2 +""") +data = yaml.load("""\ +a: 1 +b: 2 +""",) +data = yaml.load( + """\ + a: 1 + b: 2 +""" +) + +MULTILINE = """ +foo +""".replace("\n", "") +generated_readme = lambda project_name: """ +{} + + +""".strip().format(project_name) +parser.usage += """ +Custom extra help summary. + +Extra test: +- with +- bullets +""" + + +def get_stuff(cr, value): + # original + cr.execute(""" + SELECT whatever + FROM some_table t + WHERE id = %s + """, [value]) + return cr.fetchone() + + +def get_stuff(cr, value): + # preferred + cr.execute( + """ + SELECT whatever + FROM some_table t + WHERE id = %s + """, + [value], + ) + return cr.fetchone() + + +call(arg1, arg2, """ +short +""", arg3=True) +test_vectors = [ + "one-liner\n", + "two\nliner\n", + """expressed +as a three line +mulitline string""", +] + +_wat = re.compile( + r""" + regex + """, + re.MULTILINE | re.VERBOSE, +) +dis_c_instance_method = """\ +%3d 0 LOAD_FAST 1 (x) + 2 LOAD_CONST 1 (1) + 4 COMPARE_OP 2 (==) + 6 LOAD_FAST 0 (self) + 8 STORE_ATTR 0 (x) + 10 LOAD_CONST 0 (None) + 12 RETURN_VALUE +""" % (_C.__init__.__code__.co_firstlineno + 1,) +path.write_text(textwrap.dedent("""\ + A triple-quoted string + actually {verb} the textwrap.dedent functionality + that ends in a trailing newline, + representing e.g. {file_type} file contents. +""".format(verb="using", file_type="test"))) +{"""cow +moos"""} +["""cow +moos"""] +["""cow +moos""", """dog +woofs +and +barks"""] +def dastardly_default_value( + cow: String = json.loads("""this +is +quite +the +dastadardly +value!"""), + **kwargs, +): + pass + +print(f""" + This {animal} + moos and barks +{animal} say +""") +msg = f"""The arguments {bad_arguments} were passed in. +Please use `--build-option` instead, +`--global-option` is reserved to flags like `--verbose` or `--quiet`. +""" + +assert some_var == expected_result, """ +test +""" +assert some_var == expected_result, f""" +expected: {expected_result} +actual: {some_var}""" + + +def foo(): + a = { + xxxx_xxxxxxx.xxxxxx_xxxxxxxxxxxx_xxxxxx_xx_xxx_xxxxxx: { + "xxxxx": """Sxxxxx xxxxxxxxxxxx xxx xxxxx (xxxxxx xxx xxxxxxx)""", + "xxxxxxxx": ( + """Sxxxxxxx xxxxxxxx, xxxxxxx xx xxxxxxxxx + xxxxxxxxxxxxx xxxxxxx xxxxxxxxx xxx-xxxxxxxxxx xxxxxx xx xxx-xxxxxx""" + ), + "xxxxxxxx": """Sxxxxxxx xxxxxxxx, xxxxxxx xx xxxxxxxxx + xxxxxxxxxxxxx xxxxxxx xxxxxxxxx xxx-xxxxxxxxxx xxxxxx xx xxx-xxxxxx""" + }, + } + + +xxxx_xxxxxxx.xxxxxx_xxxxxxxxxxxx_xxxxxx_xx_xxx_xxxxxx = { + "xxxxx": """Sxxxxx xxxxxxxxxxxx xxx xxxxx (xxxxxx xxx xxxxxxx)""", + "xxxxxxxx": ( + """Sxxxxxxx xxxxxxxx, xxxxxxx xx xxxxxxxxx + xxxxxxxxxxxxx xxxxxxx xxxxxxxxx xxx-xxxxxxxxxx xxxxxx xx xxx-xxxxxx""" + ), + "xxxxx_xxxxxxxxxx_xxxxxxxxx_xx": ( + """ +a +a +a +a +a""" + ), + "xx_xxxxx_xxxxxxxxxx_xxxxxxxxx_xx": """ +a +a +a +a +a""", +} + +a = """ +""" if """ +""" == """ +""" else """ +""" + +a = """ +""" if b else """ +""" + +a = """ +""" if """ +""" == """ +""" else b + +a = b if """ +""" == """ +""" else """ +""" + +a = """ +""" if b else c + +a = c if b else """ +""" + +a = b if """ +""" == """ +""" else c + +# output + +"""cow +say""", +call( + 3, + "dogsay", + textwrap.dedent("""dove + coo""" % "cowabunga"), +) +call( + 3, + "dogsay", + textwrap.dedent("""dove +coo""" % "cowabunga"), +) +call( + 3, + textwrap.dedent("""cow + moo""" % "cowabunga"), + "dogsay", +) +call( + 3, + "dogsay", + textwrap.dedent("""crow + caw""" % "cowabunga"), +) +call( + 3, + textwrap.dedent("""cat + meow""" % "cowabunga"), + {"dog", "say"}, +) +call( + 3, + {"dog", "say"}, + textwrap.dedent("""horse + neigh""" % "cowabunga"), +) +call( + 3, + {"dog", "say"}, + textwrap.dedent("""pig + oink""" % "cowabunga"), +) +textwrap.dedent("""A one-line triple-quoted string.""") +textwrap.dedent("""A two-line triple-quoted string +since it goes to the next line.""") +textwrap.dedent("""A three-line triple-quoted string +that not only goes to the next line +but also goes one line beyond.""") +textwrap.dedent("""\ + A triple-quoted string + actually leveraging the textwrap.dedent functionality + that ends in a trailing newline, + representing e.g. file contents. +""") +path.write_text(textwrap.dedent("""\ + A triple-quoted string + actually leveraging the textwrap.dedent functionality + that ends in a trailing newline, + representing e.g. file contents. +""")) +path.write_text(textwrap.dedent("""\ + A triple-quoted string + actually leveraging the textwrap.dedent functionality + that ends in a trailing newline, + representing e.g. {config_filename} file contents. +""".format("config_filename", config_filename))) +# Another use case +data = yaml.load("""\ +a: 1 +b: 2 +""") +data = yaml.load( + """\ +a: 1 +b: 2 +""", +) +data = yaml.load("""\ + a: 1 + b: 2 +""") + +MULTILINE = """ +foo +""".replace("\n", "") +generated_readme = lambda project_name: """ +{} + + +""".strip().format(project_name) +parser.usage += """ +Custom extra help summary. + +Extra test: +- with +- bullets +""" + + +def get_stuff(cr, value): + # original + cr.execute( + """ + SELECT whatever + FROM some_table t + WHERE id = %s + """, + [value], + ) + return cr.fetchone() + + +def get_stuff(cr, value): + # preferred + cr.execute( + """ + SELECT whatever + FROM some_table t + WHERE id = %s + """, + [value], + ) + return cr.fetchone() + + +call( + arg1, + arg2, + """ +short +""", + arg3=True, +) +test_vectors = [ + "one-liner\n", + "two\nliner\n", + """expressed +as a three line +mulitline string""", +] + +_wat = re.compile( + r""" + regex + """, + re.MULTILINE | re.VERBOSE, +) +dis_c_instance_method = """\ +%3d 0 LOAD_FAST 1 (x) + 2 LOAD_CONST 1 (1) + 4 COMPARE_OP 2 (==) + 6 LOAD_FAST 0 (self) + 8 STORE_ATTR 0 (x) + 10 LOAD_CONST 0 (None) + 12 RETURN_VALUE +""" % (_C.__init__.__code__.co_firstlineno + 1,) +path.write_text(textwrap.dedent("""\ + A triple-quoted string + actually {verb} the textwrap.dedent functionality + that ends in a trailing newline, + representing e.g. {file_type} file contents. +""".format(verb="using", file_type="test"))) +{"""cow +moos"""} +["""cow +moos"""] +[ + """cow +moos""", + """dog +woofs +and +barks""", +] + + +def dastardly_default_value( + cow: String = json.loads("""this +is +quite +the +dastadardly +value!"""), + **kwargs, +): + pass + + +print(f""" + This {animal} + moos and barks +{animal} say +""") +msg = f"""The arguments {bad_arguments} were passed in. +Please use `--build-option` instead, +`--global-option` is reserved to flags like `--verbose` or `--quiet`. +""" + +assert some_var == expected_result, """ +test +""" +assert some_var == expected_result, f""" +expected: {expected_result} +actual: {some_var}""" + + +def foo(): + a = { + xxxx_xxxxxxx.xxxxxx_xxxxxxxxxxxx_xxxxxx_xx_xxx_xxxxxx: { + "xxxxx": """Sxxxxx xxxxxxxxxxxx xxx xxxxx (xxxxxx xxx xxxxxxx)""", + "xxxxxxxx": ( + """Sxxxxxxx xxxxxxxx, xxxxxxx xx xxxxxxxxx + xxxxxxxxxxxxx xxxxxxx xxxxxxxxx xxx-xxxxxxxxxx xxxxxx xx xxx-xxxxxx""" + ), + "xxxxxxxx": """Sxxxxxxx xxxxxxxx, xxxxxxx xx xxxxxxxxx + xxxxxxxxxxxxx xxxxxxx xxxxxxxxx xxx-xxxxxxxxxx xxxxxx xx xxx-xxxxxx""", + }, + } + + +xxxx_xxxxxxx.xxxxxx_xxxxxxxxxxxx_xxxxxx_xx_xxx_xxxxxx = { + "xxxxx": """Sxxxxx xxxxxxxxxxxx xxx xxxxx (xxxxxx xxx xxxxxxx)""", + "xxxxxxxx": ( + """Sxxxxxxx xxxxxxxx, xxxxxxx xx xxxxxxxxx + xxxxxxxxxxxxx xxxxxxx xxxxxxxxx xxx-xxxxxxxxxx xxxxxx xx xxx-xxxxxx""" + ), + "xxxxx_xxxxxxxxxx_xxxxxxxxx_xx": ( + """ +a +a +a +a +a""" + ), + "xx_xxxxx_xxxxxxxxxx_xxxxxxxxx_xx": """ +a +a +a +a +a""", +} + +a = ( + """ +""" + if """ +""" + == """ +""" + else """ +""" +) + +a = ( + """ +""" + if b + else """ +""" +) + +a = ( + """ +""" + if """ +""" + == """ +""" + else b +) + +a = ( + b + if """ +""" + == """ +""" + else """ +""" +) + +a = ( + """ +""" + if b + else c +) + +a = ( + c + if b + else """ +""" +) + +a = ( + b + if """ +""" + == """ +""" + else c +) diff --git a/tests/data/cases/nested_stub.py b/tests/data/cases/nested_stub.py new file mode 100644 index 0000000..40ca11e --- /dev/null +++ b/tests/data/cases/nested_stub.py @@ -0,0 +1,69 @@ +# flags: --pyi +import sys + +class Outer: + class InnerStub: ... + outer_attr_after_inner_stub: int + class Inner: + inner_attr: int + outer_attr: int + +if sys.version_info > (3, 7): + if sys.platform == "win32": + assignment = 1 + def function_definition(self): ... + def f1(self) -> str: ... + if sys.platform != "win32": + def function_definition(self): ... + assignment = 1 + def f2(self) -> str: ... + + +class TopLevel: + class Nested1: + foo: int + def bar(self): ... + field = 1 + + class Nested2: + def bar(self): ... + foo: int + field = 1 + +# output + +import sys + +class Outer: + class InnerStub: ... + outer_attr_after_inner_stub: int + + class Inner: + inner_attr: int + + outer_attr: int + +if sys.version_info > (3, 7): + if sys.platform == "win32": + assignment = 1 + def function_definition(self): ... + + def f1(self) -> str: ... + if sys.platform != "win32": + def function_definition(self): ... + assignment = 1 + + def f2(self) -> str: ... + +class TopLevel: + class Nested1: + foo: int + def bar(self): ... + + field = 1 + + class Nested2: + def bar(self): ... + foo: int + + field = 1 diff --git a/tests/data/cases/no_blank_line_before_docstring.py b/tests/data/cases/no_blank_line_before_docstring.py new file mode 100644 index 0000000..74d43cd --- /dev/null +++ b/tests/data/cases/no_blank_line_before_docstring.py @@ -0,0 +1,65 @@ +def line_before_docstring(): + + """Please move me up""" + + +class LineBeforeDocstring: + + """Please move me up""" + + +class EvenIfThereIsAMethodAfter: + + """I'm the docstring""" + def method(self): + pass + + +class TwoLinesBeforeDocstring: + + + """I want to be treated the same as if I were closer""" + + +class MultilineDocstringsAsWell: + + """I'm so far + + and on so many lines... + """ + +class SingleQuotedDocstring: + + "I'm a docstring but I don't even get triple quotes." + +# output + + +def line_before_docstring(): + """Please move me up""" + + +class LineBeforeDocstring: + """Please move me up""" + + +class EvenIfThereIsAMethodAfter: + """I'm the docstring""" + + def method(self): + pass + + +class TwoLinesBeforeDocstring: + """I want to be treated the same as if I were closer""" + + +class MultilineDocstringsAsWell: + """I'm so far + + and on so many lines... + """ + + +class SingleQuotedDocstring: + "I'm a docstring but I don't even get triple quotes." diff --git a/tests/data/cases/numeric_literals.py b/tests/data/cases/numeric_literals.py new file mode 100644 index 0000000..9966932 --- /dev/null +++ b/tests/data/cases/numeric_literals.py @@ -0,0 +1,39 @@ +x = 123456789 +x = 123456 +x = .1 +x = 1. +x = 1E+1 +x = 1E-1 +x = 1.000_000_01 +x = 123456789.123456789 +x = 123456789.123456789E123456789 +x = 123456789E123456789 +x = 123456789J +x = 123456789.123456789J +x = 0XB1ACC +x = 0B1011 +x = 0O777 +x = 0.000000006 +x = 10000 +x = 133333 + +# output + +x = 123456789 +x = 123456 +x = 0.1 +x = 1.0 +x = 1e1 +x = 1e-1 +x = 1.000_000_01 +x = 123456789.123456789 +x = 123456789.123456789e123456789 +x = 123456789e123456789 +x = 123456789j +x = 123456789.123456789j +x = 0xB1ACC +x = 0b1011 +x = 0o777 +x = 0.000000006 +x = 10000 +x = 133333 diff --git a/tests/data/cases/numeric_literals_skip_underscores.py b/tests/data/cases/numeric_literals_skip_underscores.py new file mode 100644 index 0000000..6d60bdb --- /dev/null +++ b/tests/data/cases/numeric_literals_skip_underscores.py @@ -0,0 +1,19 @@ +x = 123456789 +x = 1_2_3_4_5_6_7 +x = 1E+1 +x = 0xb1acc +x = 0.00_00_006 +x = 12_34_567J +x = .1_2 +x = 1_2. + +# output + +x = 123456789 +x = 1_2_3_4_5_6_7 +x = 1e1 +x = 0xB1ACC +x = 0.00_00_006 +x = 12_34_567j +x = 0.1_2 +x = 1_2.0 \ No newline at end of file diff --git a/tests/data/cases/one_element_subscript.py b/tests/data/cases/one_element_subscript.py new file mode 100644 index 0000000..39205ba --- /dev/null +++ b/tests/data/cases/one_element_subscript.py @@ -0,0 +1,36 @@ +# We should not treat the trailing comma +# in a single-element subscript. +a: tuple[int,] +b = tuple[int,] + +# The magic comma still applies to multi-element subscripts. +c: tuple[int, int,] +d = tuple[int, int,] + +# Magic commas still work as expected for non-subscripts. +small_list = [1,] +list_of_types = [tuple[int,],] + +# output +# We should not treat the trailing comma +# in a single-element subscript. +a: tuple[int,] +b = tuple[int,] + +# The magic comma still applies to multi-element subscripts. +c: tuple[ + int, + int, +] +d = tuple[ + int, + int, +] + +# Magic commas still work as expected for non-subscripts. +small_list = [ + 1, +] +list_of_types = [ + tuple[int,], +] diff --git a/tests/data/cases/parenthesized_context_managers.py b/tests/data/cases/parenthesized_context_managers.py new file mode 100644 index 0000000..16645a1 --- /dev/null +++ b/tests/data/cases/parenthesized_context_managers.py @@ -0,0 +1,46 @@ +# flags: --minimum-version=3.10 +with (CtxManager() as example): + ... + +with (CtxManager1(), CtxManager2()): + ... + +with (CtxManager1() as example, CtxManager2()): + ... + +with (CtxManager1(), CtxManager2() as example): + ... + +with (CtxManager1() as example1, CtxManager2() as example2): + ... + +with ( + CtxManager1() as example1, + CtxManager2() as example2, + CtxManager3() as example3, +): + ... + +# output + +with CtxManager() as example: + ... + +with CtxManager1(), CtxManager2(): + ... + +with CtxManager1() as example, CtxManager2(): + ... + +with CtxManager1(), CtxManager2() as example: + ... + +with CtxManager1() as example1, CtxManager2() as example2: + ... + +with ( + CtxManager1() as example1, + CtxManager2() as example2, + CtxManager3() as example3, +): + ... diff --git a/tests/data/cases/pattern_matching_case_case_small_line_length.py b/tests/data/cases/pattern_matching_case_case_small_line_length.py new file mode 100644 index 0000000..8557cc4 --- /dev/null +++ b/tests/data/cases/pattern_matching_case_case_small_line_length.py @@ -0,0 +1,13 @@ +# flags: --minimum-version=3.10 --line-length=10 + +match test: + case case if True: + pass + +# output + +match test: + case ( + case + ) if True: + pass diff --git a/tests/data/cases/pattern_matching_complex.py b/tests/data/cases/pattern_matching_complex.py new file mode 100644 index 0000000..028832d --- /dev/null +++ b/tests/data/cases/pattern_matching_complex.py @@ -0,0 +1,155 @@ +# flags: --minimum-version=3.10 +# Cases sampled from Lib/test/test_patma.py + +# case black_test_patma_098 +match x: + case -0j: + y = 0 +# case black_test_patma_142 +match x: + case bytes(z): + y = 0 +# case black_test_patma_073 +match x: + case 0 if 0: + y = 0 + case 0 if 1: + y = 1 +# case black_test_patma_006 +match 3: + case 0 | 1 | 2 | 3: + x = True +# case black_test_patma_049 +match x: + case [0, 1] | [1, 0]: + y = 0 +# case black_check_sequence_then_mapping +match x: + case [*_]: + return "seq" + case {}: + return "map" +# case black_test_patma_035 +match x: + case {0: [1, 2, {}]}: + y = 0 + case {0: [1, 2, {}] | True} | {1: [[]]} | {0: [1, 2, {}]} | [] | "X" | {}: + y = 1 + case []: + y = 2 +# case black_test_patma_107 +match x: + case 0.25 + 1.75j: + y = 0 +# case black_test_patma_097 +match x: + case -0j: + y = 0 +# case black_test_patma_007 +match 4: + case 0 | 1 | 2 | 3: + x = True +# case black_test_patma_154 +match x: + case 0 if x: + y = 0 +# case black_test_patma_134 +match x: + case {1: 0}: + y = 0 + case {0: 0}: + y = 1 + case {**z}: + y = 2 +# case black_test_patma_185 +match Seq(): + case [*_]: + y = 0 +# case black_test_patma_063 +match x: + case 1: + y = 0 + case 1: + y = 1 +# case black_test_patma_248 +match x: + case {"foo": bar}: + y = bar +# case black_test_patma_019 +match (0, 1, 2): + case [0, 1, *x, 2]: + y = 0 +# case black_test_patma_052 +match x: + case [0]: + y = 0 + case [1, 0] if x := x[:0]: + y = 1 + case [1, 0]: + y = 2 +# case black_test_patma_191 +match w: + case [x, y, *_]: + z = 0 +# case black_test_patma_110 +match x: + case -0.25 - 1.75j: + y = 0 +# case black_test_patma_151 +match (x,): + case [y]: + z = 0 +# case black_test_patma_114 +match x: + case A.B.C.D: + y = 0 +# case black_test_patma_232 +match x: + case None: + y = 0 +# case black_test_patma_058 +match x: + case 0: + y = 0 +# case black_test_patma_233 +match x: + case False: + y = 0 +# case black_test_patma_078 +match x: + case []: + y = 0 + case [""]: + y = 1 + case "": + y = 2 +# case black_test_patma_156 +match x: + case z: + y = 0 +# case black_test_patma_189 +match w: + case [x, y, *rest]: + z = 0 +# case black_test_patma_042 +match x: + case (0 as z) | (1 as z) | (2 as z) if z == x % 2: + y = 0 +# case black_test_patma_034 +match x: + case {0: [1, 2, {}]}: + y = 0 + case {0: [1, 2, {}] | False} | {1: [[]]} | {0: [1, 2, {}]} | [] | "X" | {}: + y = 1 + case []: + y = 2 +# issue 3790 +match (X.type, Y): + case _: + pass +# issue 3487 +match = re.match(r"(?PLD|MD|HD)(?PAL|SS)", "HDSS") + +match (match.group("grade"), match.group("material")): + case ("MD" | "HD", "SS" as code): + print("You will get here") diff --git a/tests/data/cases/pattern_matching_extras.py b/tests/data/cases/pattern_matching_extras.py new file mode 100644 index 0000000..1aef8f1 --- /dev/null +++ b/tests/data/cases/pattern_matching_extras.py @@ -0,0 +1,102 @@ +# flags: --minimum-version=3.10 +import match + +match something: + case [a as b]: + print(b) + case [a as b, c, d, e as f]: + print(f) + case Point(a as b): + print(b) + case Point(int() as x, int() as y): + print(x, y) + + +match = 1 +case: int = re.match(something) + +match re.match(case): + case type("match", match): + pass + case match: + pass + + +def func(match: case, case: match) -> case: + match Something(): + case func(match, case): + ... + case another: + ... + + +match a, *b, c: + case [*_]: + assert "seq" == _ + case {}: + assert "map" == b + + +match match( + case, + match( + match, case, match, looooooooooooooooooooooooooooooooooooong, match, case, match + ), + case, +): + case case( + match=case, + case=re.match( + loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong + ), + ): + pass + case [a as match]: + pass + case case: + pass + case something: + pass + + +match match: + case case: + pass + + +match a, *b(), c: + case d, *f, g: + pass + + +match something: + case { + "key": key as key_1, + "password": PASS.ONE | PASS.TWO | PASS.THREE as password, + }: + pass + case {"maybe": something(complicated as this) as that}: + pass + + +match something: + case 1 as a: + pass + case 2 as b, 3 as c: + pass + case 4 as d, (5 as e), (6 | 7 as g), *h: + pass + + +match bar1: + case Foo(aa=Callable() as aa, bb=int()): + print(bar1.aa, bar1.bb) + case _: + print("no match", "\n") + + +match bar1: + case Foo( + normal=x, perhaps=[list, {"x": d, "y": 1.0}] as y, otherwise=something, q=t as u + ): + pass diff --git a/tests/data/cases/pattern_matching_generic.py b/tests/data/cases/pattern_matching_generic.py new file mode 100644 index 0000000..4b4d45f --- /dev/null +++ b/tests/data/cases/pattern_matching_generic.py @@ -0,0 +1,108 @@ +# flags: --minimum-version=3.10 +re.match() +match = a +with match() as match: + match = f"{match}" + +re.match() +match = a +with match() as match: + match = f"{match}" + + +def get_grammars(target_versions: Set[TargetVersion]) -> List[Grammar]: + if not target_versions: + # No target_version specified, so try all grammars. + return [ + # Python 3.7+ + pygram.python_grammar_no_print_statement_no_exec_statement_async_keywords, + # Python 3.0-3.6 + pygram.python_grammar_no_print_statement_no_exec_statement, + # Python 2.7 with future print_function import + pygram.python_grammar_no_print_statement, + # Python 2.7 + pygram.python_grammar, + ] + + match match: + case case: + match match: + case case: + pass + + if all(version.is_python2() for version in target_versions): + # Python 2-only code, so try Python 2 grammars. + return [ + # Python 2.7 with future print_function import + pygram.python_grammar_no_print_statement, + # Python 2.7 + pygram.python_grammar, + ] + + re.match() + match = a + with match() as match: + match = f"{match}" + + def test_patma_139(self): + x = False + match x: + case bool(z): + y = 0 + self.assertIs(x, False) + self.assertEqual(y, 0) + self.assertIs(z, x) + + # Python 3-compatible code, so only try Python 3 grammar. + grammars = [] + if supports_feature(target_versions, Feature.PATTERN_MATCHING): + # Python 3.10+ + grammars.append(pygram.python_grammar_soft_keywords) + # If we have to parse both, try to parse async as a keyword first + if not supports_feature( + target_versions, Feature.ASYNC_IDENTIFIERS + ) and not supports_feature(target_versions, Feature.PATTERN_MATCHING): + # Python 3.7-3.9 + grammars.append( + pygram.python_grammar_no_print_statement_no_exec_statement_async_keywords + ) + if not supports_feature(target_versions, Feature.ASYNC_KEYWORDS): + # Python 3.0-3.6 + grammars.append(pygram.python_grammar_no_print_statement_no_exec_statement) + + def test_patma_155(self): + x = 0 + y = None + match x: + case 1e1000: + y = 0 + self.assertEqual(x, 0) + self.assertIs(y, None) + + x = range(3) + match x: + case [y, case as x, z]: + w = 0 + + # At least one of the above branches must have been taken, because every Python + # version has exactly one of the two 'ASYNC_*' flags + return grammars + + +def lib2to3_parse(src_txt: str, target_versions: Iterable[TargetVersion] = ()) -> Node: + """Given a string with source, return the lib2to3 Node.""" + if not src_txt.endswith("\n"): + src_txt += "\n" + + grammars = get_grammars(set(target_versions)) + + +re.match() +match = a +with match() as match: + match = f"{match}" + +re.match() +match = a +with match() as match: + match = f"{match}" diff --git a/tests/data/cases/pattern_matching_long.py b/tests/data/cases/pattern_matching_long.py new file mode 100644 index 0000000..9a944c9 --- /dev/null +++ b/tests/data/cases/pattern_matching_long.py @@ -0,0 +1,34 @@ +# flags: --minimum-version=3.10 +match x: + case "abcd" | "abcd" | "abcd" : + pass + case "abcd" | "abcd" | "abcd" | "abcd" | "abcd" | "abcd" | "abcd" | "abcd" | "abcd" | "abcd" | "abcd" | "abcd" | "abcd" | "abcd" | "abcd": + pass + case xxxxxxxxxxxxxxxxxxxxxxx: + pass + +# output + +match x: + case "abcd" | "abcd" | "abcd": + pass + case ( + "abcd" + | "abcd" + | "abcd" + | "abcd" + | "abcd" + | "abcd" + | "abcd" + | "abcd" + | "abcd" + | "abcd" + | "abcd" + | "abcd" + | "abcd" + | "abcd" + | "abcd" + ): + pass + case xxxxxxxxxxxxxxxxxxxxxxx: + pass diff --git a/tests/data/cases/pattern_matching_simple.py b/tests/data/cases/pattern_matching_simple.py new file mode 100644 index 0000000..6fa2000 --- /dev/null +++ b/tests/data/cases/pattern_matching_simple.py @@ -0,0 +1,93 @@ +# flags: --minimum-version=3.10 +# Cases sampled from PEP 636 examples + +match command.split(): + case [action, obj]: + ... # interpret action, obj + +match command.split(): + case [action]: + ... # interpret single-verb action + case [action, obj]: + ... # interpret action, obj + +match command.split(): + case ["quit"]: + print("Goodbye!") + quit_game() + case ["look"]: + current_room.describe() + case ["get", obj]: + character.get(obj, current_room) + case ["go", direction]: + current_room = current_room.neighbor(direction) + # The rest of your commands go here + +match command.split(): + case ["drop", *objects]: + for obj in objects: + character.drop(obj, current_room) + # The rest of your commands go here + +match command.split(): + case ["quit"]: + pass + case ["go", direction]: + print("Going:", direction) + case ["drop", *objects]: + print("Dropping: ", *objects) + case _: + print(f"Sorry, I couldn't understand {command!r}") + +match command.split(): + case ["north"] | ["go", "north"]: + current_room = current_room.neighbor("north") + case ["get", obj] | ["pick", "up", obj] | ["pick", obj, "up"]: + ... # Code for picking up the given object + +match command.split(): + case ["go", ("north" | "south" | "east" | "west")]: + current_room = current_room.neighbor(...) + # how do I know which direction to go? + +match command.split(): + case ["go", ("north" | "south" | "east" | "west") as direction]: + current_room = current_room.neighbor(direction) + +match command.split(): + case ["go", direction] if direction in current_room.exits: + current_room = current_room.neighbor(direction) + case ["go", _]: + print("Sorry, you can't go that way") + +match event.get(): + case Click(position=(x, y)): + handle_click_at(x, y) + case KeyPress(key_name="Q") | Quit(): + game.quit() + case KeyPress(key_name="up arrow"): + game.go_north() + case KeyPress(): + pass # Ignore other keystrokes + case other_event: + raise ValueError(f"Unrecognized event: {other_event}") + +match event.get(): + case Click((x, y), button=Button.LEFT): # This is a left click + handle_click_at(x, y) + case Click(): + pass # ignore other clicks + + +def where_is(point): + match point: + case Point(x=0, y=0): + print("Origin") + case Point(x=0, y=y): + print(f"Y={y}") + case Point(x=x, y=0): + print(f"X={x}") + case Point(): + print("Somewhere else") + case _: + print("Not a point") diff --git a/tests/data/cases/pattern_matching_style.py b/tests/data/cases/pattern_matching_style.py new file mode 100644 index 0000000..2ee6ea2 --- /dev/null +++ b/tests/data/cases/pattern_matching_style.py @@ -0,0 +1,92 @@ +# flags: --minimum-version=3.10 +match something: + case b(): print(1+1) + case c( + very_complex=True, + perhaps_even_loooooooooooooooooooooooooooooooooooooong=- 1 + ): print(1) + case c( + very_complex=True, + perhaps_even_loooooooooooooooooooooooooooooooooooooong=-1, + ): print(2) + case a: pass + +match( + arg # comment +) + +match( +) + +match( + + +) + +case( + arg # comment +) + +case( +) + +case( + + +) + + +re.match( + something # fast +) +re.match( + + + +) +match match( + + +): + case case( + arg, # comment + ): + pass + +# output + +match something: + case b(): + print(1 + 1) + case c( + very_complex=True, perhaps_even_loooooooooooooooooooooooooooooooooooooong=-1 + ): + print(1) + case c( + very_complex=True, + perhaps_even_loooooooooooooooooooooooooooooooooooooong=-1, + ): + print(2) + case a: + pass + +match(arg) # comment + +match() + +match() + +case(arg) # comment + +case() + +case() + + +re.match(something) # fast +re.match() +match match(): + case case( + arg, # comment + ): + pass diff --git a/tests/data/cases/pattern_matching_trailing_comma.py b/tests/data/cases/pattern_matching_trailing_comma.py new file mode 100644 index 0000000..5660b0f --- /dev/null +++ b/tests/data/cases/pattern_matching_trailing_comma.py @@ -0,0 +1,39 @@ +# flags: --minimum-version=3.10 +match maybe, multiple: + case perhaps, 5: + pass + case perhaps, 6,: + pass + + +match more := (than, one), indeed,: + case _, (5, 6): + pass + case [[5], (6)], [7],: + pass + case _: + pass + + +# output + +match maybe, multiple: + case perhaps, 5: + pass + case ( + perhaps, + 6, + ): + pass + + +match more := (than, one), indeed,: + case _, (5, 6): + pass + case ( + [[5], (6)], + [7], + ): + pass + case _: + pass \ No newline at end of file diff --git a/tests/data/cases/pattern_matching_with_if_stmt.py b/tests/data/cases/pattern_matching_with_if_stmt.py new file mode 100644 index 0000000..1c5d58f --- /dev/null +++ b/tests/data/cases/pattern_matching_with_if_stmt.py @@ -0,0 +1,72 @@ +# flags: --minimum-version=3.10 +match match: + case "test" if case != "not very loooooooooooooog condition": # comment + pass + +match smth: + case "test" if "any long condition" != "another long condition" and "this is a long condition": + pass + case test if "any long condition" != "another long condition" and "this is a looooong condition": + pass + case test if "any long condition" != "another long condition" and "this is a looooong condition": # some additional comments + pass + case test if (True): # some comment + pass + case test if (False + ): # some comment + pass + case test if (True # some comment + ): + pass # some comment + case cases if (True # some comment + ): # some other comment + pass # some comment + case match if (True # some comment + ): + pass # some comment + +# case black_test_patma_052 (originally in the pattern_matching_complex test case) +match x: + case [1, 0] if x := x[:0]: + y = 1 + case [1, 0] if (x := x[:0]): + y = 1 + +# output + +match match: + case "test" if case != "not very loooooooooooooog condition": # comment + pass + +match smth: + case "test" if ( + "any long condition" != "another long condition" and "this is a long condition" + ): + pass + case test if ( + "any long condition" != "another long condition" + and "this is a looooong condition" + ): + pass + case test if ( + "any long condition" != "another long condition" + and "this is a looooong condition" + ): # some additional comments + pass + case test if True: # some comment + pass + case test if False: # some comment + pass + case test if True: # some comment + pass # some comment + case cases if True: # some comment # some other comment + pass # some comment + case match if True: # some comment + pass # some comment + +# case black_test_patma_052 (originally in the pattern_matching_complex test case) +match x: + case [1, 0] if x := x[:0]: + y = 1 + case [1, 0] if x := x[:0]: + y = 1 diff --git a/tests/data/cases/pep604_union_types_line_breaks.py b/tests/data/cases/pep604_union_types_line_breaks.py new file mode 100644 index 0000000..b8e7d5b --- /dev/null +++ b/tests/data/cases/pep604_union_types_line_breaks.py @@ -0,0 +1,216 @@ +# flags: --minimum-version=3.10 +# This has always worked +z= Loooooooooooooooooooooooong | Loooooooooooooooooooooooong | Loooooooooooooooooooooooong | Loooooooooooooooooooooooong + +# "AnnAssign"s now also work +z: Loooooooooooooooooooooooong | Loooooooooooooooooooooooong | Loooooooooooooooooooooooong | Loooooooooooooooooooooooong +z: (Short + | Short2 + | Short3 + | Short4) +z: (int) +z: ((int)) + + +z: Loooooooooooooooooooooooong | Loooooooooooooooooooooooong | Loooooooooooooooooooooooong | Loooooooooooooooooooooooong = 7 +z: (Short + | Short2 + | Short3 + | Short4) = 8 +z: (int) = 2.3 +z: ((int)) = foo() + +# In case I go for not enforcing parantheses, this might get improved at the same time +x = ( + z + == 9999999999999999999999999999999999999999 + | 9999999999999999999999999999999999999999 + | 9999999999999999999999999999999999999999 + | 9999999999999999999999999999999999999999, + y + == 9999999999999999999999999999999999999999 + + 9999999999999999999999999999999999999999 + + 9999999999999999999999999999999999999999 + + 9999999999999999999999999999999999999999, +) + +x = ( + z == (9999999999999999999999999999999999999999 + | 9999999999999999999999999999999999999999 + | 9999999999999999999999999999999999999999 + | 9999999999999999999999999999999999999999), + y == (9999999999999999999999999999999999999999 + + 9999999999999999999999999999999999999999 + + 9999999999999999999999999999999999999999 + + 9999999999999999999999999999999999999999), +) + +# handle formatting of "tname"s in parameter list + +# remove unnecessary paren +def foo(i: (int)) -> None: ... + + +# this is a syntax error in the type annotation according to mypy, but it's not invalid *python* code, so make sure we don't mess with it and make it so. +def foo(i: (int,)) -> None: ... + +def foo( + i: int, + x: Loooooooooooooooooooooooong + | Looooooooooooooooong + | Looooooooooooooooooooong + | Looooooong, + *, + s: str, +) -> None: + pass + + +@app.get("/path/") +async def foo( + q: str + | None = Query(None, title="Some long title", description="Some long description") +): + pass + + +def f( + max_jobs: int + | None = Option( + None, help="Maximum number of jobs to launch. And some additional text." + ), + another_option: bool = False + ): + ... + + +def get_requires_for_build_sdist( + config_settings: dict[str, str | list[str]] + | None = None, +) -> list[str]: + return ["pathspec", "pyproject_metadata"] + + +def get_requires_for_build_sdist( + # pylint: disable-next=unused-argument + config_settings: dict[str, str | list[str]] + | None = None, +) -> list[str]: + return ["pathspec", "pyproject_metadata"] + + +# output +# This has always worked +z = ( + Loooooooooooooooooooooooong + | Loooooooooooooooooooooooong + | Loooooooooooooooooooooooong + | Loooooooooooooooooooooooong +) + +# "AnnAssign"s now also work +z: ( + Loooooooooooooooooooooooong + | Loooooooooooooooooooooooong + | Loooooooooooooooooooooooong + | Loooooooooooooooooooooooong +) +z: Short | Short2 | Short3 | Short4 +z: int +z: int + + +z: ( + Loooooooooooooooooooooooong + | Loooooooooooooooooooooooong + | Loooooooooooooooooooooooong + | Loooooooooooooooooooooooong +) = 7 +z: Short | Short2 | Short3 | Short4 = 8 +z: int = 2.3 +z: int = foo() + +# In case I go for not enforcing parantheses, this might get improved at the same time +x = ( + z + == 9999999999999999999999999999999999999999 + | 9999999999999999999999999999999999999999 + | 9999999999999999999999999999999999999999 + | 9999999999999999999999999999999999999999, + y + == 9999999999999999999999999999999999999999 + + 9999999999999999999999999999999999999999 + + 9999999999999999999999999999999999999999 + + 9999999999999999999999999999999999999999, +) + +x = ( + z + == ( + 9999999999999999999999999999999999999999 + | 9999999999999999999999999999999999999999 + | 9999999999999999999999999999999999999999 + | 9999999999999999999999999999999999999999 + ), + y + == ( + 9999999999999999999999999999999999999999 + + 9999999999999999999999999999999999999999 + + 9999999999999999999999999999999999999999 + + 9999999999999999999999999999999999999999 + ), +) + +# handle formatting of "tname"s in parameter list + + +# remove unnecessary paren +def foo(i: int) -> None: ... + + +# this is a syntax error in the type annotation according to mypy, but it's not invalid *python* code, so make sure we don't mess with it and make it so. +def foo(i: (int,)) -> None: ... + + +def foo( + i: int, + x: ( + Loooooooooooooooooooooooong + | Looooooooooooooooong + | Looooooooooooooooooooong + | Looooooong + ), + *, + s: str, +) -> None: + pass + + +@app.get("/path/") +async def foo( + q: str | None = Query( + None, title="Some long title", description="Some long description" + ) +): + pass + + +def f( + max_jobs: int | None = Option( + None, help="Maximum number of jobs to launch. And some additional text." + ), + another_option: bool = False, +): ... + + +def get_requires_for_build_sdist( + config_settings: dict[str, str | list[str]] | None = None, +) -> list[str]: + return ["pathspec", "pyproject_metadata"] + + +def get_requires_for_build_sdist( + # pylint: disable-next=unused-argument + config_settings: dict[str, str | list[str]] | None = None, +) -> list[str]: + return ["pathspec", "pyproject_metadata"] diff --git a/tests/data/cases/pep646_typed_star_arg_type_var_tuple.py b/tests/data/cases/pep646_typed_star_arg_type_var_tuple.py new file mode 100644 index 0000000..6dfb544 --- /dev/null +++ b/tests/data/cases/pep646_typed_star_arg_type_var_tuple.py @@ -0,0 +1,8 @@ +# flags: --minimum-version=3.11 + + +def fn(*args: *tuple[*A, B]) -> None: + pass + + +fn.__annotations__ diff --git a/tests/data/cases/pep_570.py b/tests/data/cases/pep_570.py new file mode 100644 index 0000000..ca8f7ab --- /dev/null +++ b/tests/data/cases/pep_570.py @@ -0,0 +1,44 @@ +def positional_only_arg(a, /): + pass + + +def all_markers(a, b, /, c, d, *, e, f): + pass + + +def all_markers_with_args_and_kwargs( + a_long_one, + b_long_one, + /, + c_long_one, + d_long_one, + *args, + e_long_one, + f_long_one, + **kwargs, +): + pass + + +def all_markers_with_defaults(a, b=1, /, c=2, d=3, *, e=4, f=5): + pass + + +def long_one_with_long_parameter_names( + but_all_of_them, + are_positional_only, + arguments_mmmmkay, + so_this_is_only_valid_after, + three_point_eight, + /, +): + pass + + +lambda a, /: a + +lambda a, b, /, c, d, *, e, f: a + +lambda a, b, /, c, d, *args, e, f, **kwargs: args + +lambda a, b=1, /, c=2, d=3, *, e=4, f=5: 1 diff --git a/tests/data/cases/pep_572.py b/tests/data/cases/pep_572.py new file mode 100644 index 0000000..d41805f --- /dev/null +++ b/tests/data/cases/pep_572.py @@ -0,0 +1,47 @@ +(a := 1) +(a := a) +if (match := pattern.search(data)) is None: + pass +if match := pattern.search(data): + pass +[y := f(x), y**2, y**3] +filtered_data = [y for x in data if (y := f(x)) is None] +(y := f(x)) +y0 = (y1 := f(x)) +foo(x=(y := f(x))) + + +def foo(answer=(p := 42)): + pass + + +def foo(answer: (p := 42) = 5): + pass + + +lambda: (x := 1) +(x := lambda: 1) +(x := lambda: (y := 1)) +lambda line: (m := re.match(pattern, line)) and m.group(1) +x = (y := 0) +(z := (y := (x := 0))) +(info := (name, phone, *rest)) +(x := 1, 2) +(total := total + tax) +len(lines := f.readlines()) +foo(x := 3, cat="vector") +foo(cat=(category := "vector")) +if any(len(longline := l) >= 100 for l in lines): + print(longline) +if env_base := os.environ.get("PYTHONUSERBASE", None): + return env_base +if self._is_special and (ans := self._check_nans(context=context)): + return ans +foo(b := 2, a=1) +foo((b := 2), a=1) +foo(c=(b := 2), a=1) + +while x := f(x): + pass +while x := f(x): + pass diff --git a/tests/data/cases/pep_572_do_not_remove_parens.py b/tests/data/cases/pep_572_do_not_remove_parens.py new file mode 100644 index 0000000..08dba3f --- /dev/null +++ b/tests/data/cases/pep_572_do_not_remove_parens.py @@ -0,0 +1,26 @@ +# flags: --fast +# Most of the following examples are really dumb, some of them aren't even accepted by Python, +# we're fixing them only so fuzzers (which follow the grammar which actually allows these +# examples matter of fact!) don't yell at us :p + +del (a := [1]) + +try: + pass +except (a := 1) as (b := why_does_this_exist): + pass + +for (z := 124) in (x := -124): + pass + +with (y := [3, 2, 1]) as (funfunfun := indeed): + pass + + +@(please := stop) +def sigh(): + pass + + +for (x := 3, y := 4) in y: + pass diff --git a/tests/data/cases/pep_572_py310.py b/tests/data/cases/pep_572_py310.py new file mode 100644 index 0000000..f790249 --- /dev/null +++ b/tests/data/cases/pep_572_py310.py @@ -0,0 +1,21 @@ +# flags: --minimum-version=3.10 +# Unparenthesized walruses are now allowed in indices since Python 3.10. +x[a := 0] +x[a := 0, b := 1] +x[5, b := 0] + +# Walruses are allowed inside generator expressions on function calls since 3.10. +if any(match := pattern_error.match(s) for s in buffer): + if match.group(2) == data_not_available: + # Error OK to ignore. + pass + +f(a := b + c for c in range(10)) +f((a := b + c for c in range(10)), x) +f(y=(a := b + c for c in range(10))) +f(x, (a := b + c for c in range(10)), y=z, **q) + + +# Don't remove parens when assignment expr is one of the exprs in a with statement +with x, (a := b): + pass diff --git a/tests/data/cases/pep_572_py39.py b/tests/data/cases/pep_572_py39.py new file mode 100644 index 0000000..b8b081b --- /dev/null +++ b/tests/data/cases/pep_572_py39.py @@ -0,0 +1,7 @@ +# Unparenthesized walruses are now allowed in set literals & set comprehensions +# since Python 3.9 +{x := 1, 2, 3} +{x4 := x**5 for x in range(7)} +# We better not remove the parentheses here (since it's a 3.10 feature) +x[(a := 1)] +x[(a := 1), (b := 3)] diff --git a/tests/data/cases/pep_572_remove_parens.py b/tests/data/cases/pep_572_remove_parens.py new file mode 100644 index 0000000..7511377 --- /dev/null +++ b/tests/data/cases/pep_572_remove_parens.py @@ -0,0 +1,141 @@ +if (foo := 0): + pass + +if (foo := 1): + pass + +if (y := 5 + 5): + pass + +y = (x := 0) + +y += (x := 0) + +(y := 5 + 5) + +test: int = (test2 := 2) + +a, b = (test := (1, 2)) + +# see also https://github.com/psf/black/issues/2139 +assert (foo := 42 - 12) + +foo(x=(y := f(x))) + + +def foo(answer=(p := 42)): + ... + + +def foo2(answer: (p := 42) = 5): + ... + + +lambda: (x := 1) + +a[(x := 12)] +a[:(x := 13)] + +# we don't touch expressions in f-strings but if we do one day, don't break 'em +f'{(x:=10)}' + + +def a(): + return (x := 3) + await (b := 1) + yield (a := 2) + raise (c := 3) + +def this_is_so_dumb() -> (please := no): + pass + +async def await_the_walrus(): + with (x := y): + pass + + with (x := y) as z, (a := b) as c: + pass + + with (x := await y): + pass + + with (x := await a, y := await b): + pass + + with ((x := await a, y := await b)): + pass + + with (x := await a), (y := await b): + pass + + +# output +if foo := 0: + pass + +if foo := 1: + pass + +if y := 5 + 5: + pass + +y = (x := 0) + +y += (x := 0) + +(y := 5 + 5) + +test: int = (test2 := 2) + +a, b = (test := (1, 2)) + +# see also https://github.com/psf/black/issues/2139 +assert (foo := 42 - 12) + +foo(x=(y := f(x))) + + +def foo(answer=(p := 42)): ... + + +def foo2(answer: (p := 42) = 5): ... + + +lambda: (x := 1) + +a[(x := 12)] +a[: (x := 13)] + +# we don't touch expressions in f-strings but if we do one day, don't break 'em +f"{(x:=10)}" + + +def a(): + return (x := 3) + await (b := 1) + yield (a := 2) + raise (c := 3) + + +def this_is_so_dumb() -> (please := no): + pass + + +async def await_the_walrus(): + with (x := y): + pass + + with (x := y) as z, (a := b) as c: + pass + + with (x := await y): + pass + + with (x := await a, y := await b): + pass + + with (x := await a, y := await b): + pass + + with (x := await a), (y := await b): + pass diff --git a/tests/data/cases/pep_572_slices.py b/tests/data/cases/pep_572_slices.py new file mode 100644 index 0000000..aa772b1 --- /dev/null +++ b/tests/data/cases/pep_572_slices.py @@ -0,0 +1,6 @@ +x[(a:=0):] +x[:(a:=0)] + +# output +x[(a := 0) :] +x[: (a := 0)] diff --git a/tests/data/cases/pep_604.py b/tests/data/cases/pep_604.py new file mode 100644 index 0000000..b68d59d --- /dev/null +++ b/tests/data/cases/pep_604.py @@ -0,0 +1,25 @@ +def some_very_long_name_function() -> my_module.Asdf | my_module.AnotherType | my_module.YetAnotherType | None: + pass + + +def some_very_long_name_function() -> my_module.Asdf | my_module.AnotherType | my_module.YetAnotherType | my_module.EvenMoreType | None: + pass + + +# output + + +def some_very_long_name_function() -> ( + my_module.Asdf | my_module.AnotherType | my_module.YetAnotherType | None +): + pass + + +def some_very_long_name_function() -> ( + my_module.Asdf + | my_module.AnotherType + | my_module.YetAnotherType + | my_module.EvenMoreType + | None +): + pass diff --git a/tests/data/cases/pep_646.py b/tests/data/cases/pep_646.py new file mode 100644 index 0000000..92b568a --- /dev/null +++ b/tests/data/cases/pep_646.py @@ -0,0 +1,195 @@ +# flags: --minimum-version=3.11 +A[*b] +A[*b] = 1 +A +del A[*b] +A +A[*b, *b] +A[*b, *b] = 1 +A +del A[*b, *b] +A +A[b, *b] +A[b, *b] = 1 +A +del A[b, *b] +A +A[*b, b] +A[*b, b] = 1 +A +del A[*b, b] +A +A[b, b, *b] +A[b, b, *b] = 1 +A +del A[b, b, *b] +A +A[*b, b, b] +A[*b, b, b] = 1 +A +del A[*b, b, b] +A +A[b, *b, b] +A[b, *b, b] = 1 +A +del A[b, *b, b] +A +A[b, b, *b, b] +A[b, b, *b, b] = 1 +A +del A[b, b, *b, b] +A +A[b, *b, b, b] +A[b, *b, b, b] = 1 +A +del A[b, *b, b, b] +A +A[A[b, *b, b]] +A[A[b, *b, b]] = 1 +A +del A[A[b, *b, b]] +A +A[*A[b, *b, b]] +A[*A[b, *b, b]] = 1 +A +del A[*A[b, *b, b]] +A +A[b, ...] +A[b, ...] = 1 +A +del A[b, ...] +A +A[*A[b, ...]] +A[*A[b, ...]] = 1 +A +del A[*A[b, ...]] +A +l = [1, 2, 3] +A[*l] +A[*l] = 1 +A +del A[*l] +A +A[*l, 4] +A[*l, 4] = 1 +A +del A[*l, 4] +A +A[0, *l] +A[0, *l] = 1 +A +del A[0, *l] +A +A[1:2, *l] +A[1:2, *l] = 1 +A +del A[1:2, *l] +A +repr(A[1:2, *l]) == repr(A[1:2, 1, 2, 3]) +t = (1, 2, 3) +A[*t] +A[*t] = 1 +A +del A[*t] +A +A[*t, 4] +A[*t, 4] = 1 +A +del A[*t, 4] +A +A[0, *t] +A[0, *t] = 1 +A +del A[0, *t] +A +A[1:2, *t] +A[1:2, *t] = 1 +A +del A[1:2, *t] +A +repr(A[1:2, *t]) == repr(A[1:2, 1, 2, 3]) + + +def returns_list(): + return [1, 2, 3] + + +A[returns_list()] +A[returns_list()] = 1 +A +del A[returns_list()] +A +A[returns_list(), 4] +A[returns_list(), 4] = 1 +A +del A[returns_list(), 4] +A +A[*returns_list()] +A[*returns_list()] = 1 +A +del A[*returns_list()] +A +A[*returns_list(), 4] +A[*returns_list(), 4] = 1 +A +del A[*returns_list(), 4] +A +A[0, *returns_list()] +A[0, *returns_list()] = 1 +A +del A[0, *returns_list()] +A +A[*returns_list(), *returns_list()] +A[*returns_list(), *returns_list()] = 1 +A +del A[*returns_list(), *returns_list()] +A +A[1:2, *b] +A[*b, 1:2] +A[1:2, *b, 1:2] +A[*b, 1:2, *b] +A[1:, *b] +A[*b, 1:] +A[1:, *b, 1:] +A[*b, 1:, *b] +A[:1, *b] +A[*b, :1] +A[:1, *b, :1] +A[*b, :1, *b] +A[:, *b] +A[*b, :] +A[:, *b, :] +A[*b, :, *b] +A[a * b()] +A[a * b(), *c, *d(), e * f(g * h)] +A[a * b(), :] +A[a * b(), *c, *d(), e * f(g * h) :] +A[[b] * len(c), :] + + +def f1(*args: *b): + pass + + +f1.__annotations__ + + +def f2(*args: *b, arg1): + pass + + +f2.__annotations__ + + +def f3(*args: *b, arg1: int): + pass + + +f3.__annotations__ + + +def f4(*args: *b, arg1: int = 2): + pass + + +f4.__annotations__ diff --git a/tests/data/cases/pep_654.py b/tests/data/cases/pep_654.py new file mode 100644 index 0000000..12e4918 --- /dev/null +++ b/tests/data/cases/pep_654.py @@ -0,0 +1,54 @@ +# flags: --minimum-version=3.11 +try: + raise OSError("blah") +except* ExceptionGroup as e: + pass + + +try: + async with trio.open_nursery() as nursery: + # Make two concurrent calls to child() + nursery.start_soon(child) + nursery.start_soon(child) +except* ValueError: + pass + +try: + try: + raise ValueError(42) + except: + try: + raise TypeError(int) + except* Exception: + pass + 1 / 0 +except Exception as e: + exc = e + +try: + try: + raise FalsyEG("eg", [TypeError(1), ValueError(2)]) + except* TypeError as e: + tes = e + raise + except* ValueError as e: + ves = e + pass +except Exception as e: + exc = e + +try: + try: + raise orig + except* (TypeError, ValueError) as e: + raise SyntaxError(3) from e +except BaseException as e: + exc = e + +try: + try: + raise orig + except* OSError as e: + raise TypeError(3) from e +except ExceptionGroup as e: + exc = e diff --git a/tests/data/cases/pep_654_style.py b/tests/data/cases/pep_654_style.py new file mode 100644 index 0000000..0d34650 --- /dev/null +++ b/tests/data/cases/pep_654_style.py @@ -0,0 +1,112 @@ +# flags: --minimum-version=3.11 +try: + raise OSError("blah") +except * ExceptionGroup as e: + pass + + +try: + async with trio.open_nursery() as nursery: + # Make two concurrent calls to child() + nursery.start_soon(child) + nursery.start_soon(child) +except *ValueError: + pass + +try: + try: + raise ValueError(42) + except: + try: + raise TypeError(int) + except *(Exception): + pass + 1 / 0 +except Exception as e: + exc = e + +try: + try: + raise FalsyEG("eg", [TypeError(1), ValueError(2)]) + except \ + *TypeError as e: + tes = e + raise + except * ValueError as e: + ves = e + pass +except Exception as e: + exc = e + +try: + try: + raise orig + except *(TypeError, ValueError, *OTHER_EXCEPTIONS) as e: + raise SyntaxError(3) from e +except BaseException as e: + exc = e + +try: + try: + raise orig + except\ + * OSError as e: + raise TypeError(3) from e +except ExceptionGroup as e: + exc = e + +# output + +try: + raise OSError("blah") +except* ExceptionGroup as e: + pass + + +try: + async with trio.open_nursery() as nursery: + # Make two concurrent calls to child() + nursery.start_soon(child) + nursery.start_soon(child) +except* ValueError: + pass + +try: + try: + raise ValueError(42) + except: + try: + raise TypeError(int) + except* Exception: + pass + 1 / 0 +except Exception as e: + exc = e + +try: + try: + raise FalsyEG("eg", [TypeError(1), ValueError(2)]) + except* TypeError as e: + tes = e + raise + except* ValueError as e: + ves = e + pass +except Exception as e: + exc = e + +try: + try: + raise orig + except* (TypeError, ValueError, *OTHER_EXCEPTIONS) as e: + raise SyntaxError(3) from e +except BaseException as e: + exc = e + +try: + try: + raise orig + except* OSError as e: + raise TypeError(3) from e +except ExceptionGroup as e: + exc = e diff --git a/tests/data/cases/pep_701.py b/tests/data/cases/pep_701.py new file mode 100644 index 0000000..6f86988 --- /dev/null +++ b/tests/data/cases/pep_701.py @@ -0,0 +1,276 @@ +# flags: --minimum-version=3.12 +x = f"foo" +x = f'foo' +x = f"""foo""" +x = f'''foo''' +x = f"foo {{ bar {{ baz" +x = f"foo {{ {2 + 2}bar {{ baz" +x = f'foo {{ {2 + 2}bar {{ baz' +x = f"""foo {{ {2 + 2}bar {{ baz""" +x = f'''foo {{ {2 + 2}bar {{ baz''' + +# edge case: FSTRING_MIDDLE containing only whitespace should not be stripped +x = f"{a} {b}" + +x = f"foo { + 2 + 2 +} bar baz" + +x = f"foo {{ {"a {2 + 2} b"}bar {{ baz" +x = f"foo {{ {f'a {2 + 2} b'}bar {{ baz" +x = f"foo {{ {f"a {2 + 2} b"}bar {{ baz" + +x = f"foo {{ {f'a {f"a {2 + 2} b"} b'}bar {{ baz" +x = f"foo {{ {f"a {f"a {2 + 2} b"} b"}bar {{ baz" + +x = """foo {{ {2 + 2}bar +baz""" + + +x = f"""foo {{ {2 + 2}bar {{ baz""" + +x = f"""foo {{ { + 2 + 2 +}bar {{ baz""" + + +x = f"""foo {{ { + 2 + 2 +}bar +baz""" + +x = f"""foo {{ a + foo {2 + 2}bar {{ baz + + x = f"foo {{ { + 2 + 2 # comment + }bar" + + {{ baz + + }} buzz + + {print("abc" + "def" +)} +abc""" + +# edge case: end triple quotes at index zero +f"""foo {2+2} bar +""" + +f' \' {f"'"} \' ' +f" \" {f'"'} \" " + +x = f"a{2+2:=^72}b" +x = f"a{2+2:x}b" + +rf'foo' +rf'{foo}' + +f"{x:{y}d}" + +x = f"a{2+2:=^{x}}b" +x = f"a{2+2:=^{foo(x+y**2):something else}}b" +x = f"a{2+2:=^{foo(x+y**2):something else}one more}b" +f'{(abc:=10)}' + +f"""This is a really long string, but just make sure that you reflow fstrings { + 2+2:d +}""" +f"This is a really long string, but just make sure that you reflow fstrings correctly {2+2:d}" + +f"{2+2=}" +f"{2+2 = }" +f"{ 2 + 2 = }" + +f"""foo { + datetime.datetime.now():%Y +%m +%d +}""" + +f"{ +X +!r +}" + +raise ValueError( + "xxxxxxxxxxxIncorrect --line-ranges format, expect START-END, found" + f" {lines_str!r}" + ) + +f"`escape` only permitted in {{'html', 'latex', 'latex-math'}}, \ +got {escape}" + +x = f'\N{GREEK CAPITAL LETTER DELTA} \N{SNOWMAN} {x}' +fr'\{{\}}' + +f""" + WITH {f''' + {1}_cte AS ()'''} +""" + +value: str = f'''foo +''' + +log( + f"Received operation {server_operation.name} from " + f"{self.writer._transport.get_extra_info('peername')}", # type: ignore[attr-defined] + level=0, +) + +f"{1:{f'{2}'}}" +f'{1:{f'{2}'}}' +f'{1:{2}d}' + +f'{{\\"kind\\":\\"ConfigMap\\",\\"metadata\\":{{\\"annotations\\":{{}},\\"name\\":\\"cluster-info\\",\\"namespace\\":\\"amazon-cloudwatch\\"}}}}' + +f"""{''' +'''}""" + +f"{'\''}" +f"{f'\''}" + +f'{1}\{{' +f'{2} foo \{{[\}}' +f'\{3}' +rf"\{"a"}" + +# output + +x = f"foo" +x = f"foo" +x = f"""foo""" +x = f"""foo""" +x = f"foo {{ bar {{ baz" +x = f"foo {{ {2 + 2}bar {{ baz" +x = f"foo {{ {2 + 2}bar {{ baz" +x = f"""foo {{ {2 + 2}bar {{ baz""" +x = f"""foo {{ {2 + 2}bar {{ baz""" + +# edge case: FSTRING_MIDDLE containing only whitespace should not be stripped +x = f"{a} {b}" + +x = f"foo { + 2 + 2 +} bar baz" + +x = f"foo {{ {"a {2 + 2} b"}bar {{ baz" +x = f"foo {{ {f'a {2 + 2} b'}bar {{ baz" +x = f"foo {{ {f"a {2 + 2} b"}bar {{ baz" + +x = f"foo {{ {f'a {f"a {2 + 2} b"} b'}bar {{ baz" +x = f"foo {{ {f"a {f"a {2 + 2} b"} b"}bar {{ baz" + +x = """foo {{ {2 + 2}bar +baz""" + + +x = f"""foo {{ {2 + 2}bar {{ baz""" + +x = f"""foo {{ { + 2 + 2 +}bar {{ baz""" + + +x = f"""foo {{ { + 2 + 2 +}bar +baz""" + +x = f"""foo {{ a + foo {2 + 2}bar {{ baz + + x = f"foo {{ { + 2 + 2 # comment + }bar" + + {{ baz + + }} buzz + + {print("abc" + "def" +)} +abc""" + +# edge case: end triple quotes at index zero +f"""foo {2+2} bar +""" + +f' \' {f"'"} \' ' +f" \" {f'"'} \" " + +x = f"a{2+2:=^72}b" +x = f"a{2+2:x}b" + +rf"foo" +rf"{foo}" + +f"{x:{y}d}" + +x = f"a{2+2:=^{x}}b" +x = f"a{2+2:=^{foo(x+y**2):something else}}b" +x = f"a{2+2:=^{foo(x+y**2):something else}one more}b" +f"{(abc:=10)}" + +f"""This is a really long string, but just make sure that you reflow fstrings { + 2+2:d +}""" +f"This is a really long string, but just make sure that you reflow fstrings correctly {2+2:d}" + +f"{2+2=}" +f"{2+2 = }" +f"{ 2 + 2 = }" + +f"""foo { + datetime.datetime.now():%Y +%m +%d +}""" + +f"{ +X +!r +}" + +raise ValueError( + "xxxxxxxxxxxIncorrect --line-ranges format, expect START-END, found" + f" {lines_str!r}" +) + +f"`escape` only permitted in {{'html', 'latex', 'latex-math'}}, \ +got {escape}" + +x = f"\N{GREEK CAPITAL LETTER DELTA} \N{SNOWMAN} {x}" +rf"\{{\}}" + +f""" + WITH {f''' + {1}_cte AS ()'''} +""" + +value: str = f"""foo +""" + +log( + f"Received operation {server_operation.name} from " + f"{self.writer._transport.get_extra_info('peername')}", # type: ignore[attr-defined] + level=0, +) + +f"{1:{f'{2}'}}" +f"{1:{f'{2}'}}" +f"{1:{2}d}" + +f'{{\\"kind\\":\\"ConfigMap\\",\\"metadata\\":{{\\"annotations\\":{{}},\\"name\\":\\"cluster-info\\",\\"namespace\\":\\"amazon-cloudwatch\\"}}}}' + +f"""{''' +'''}""" + +f"{'\''}" +f"{f'\''}" + +f"{1}\{{" +f"{2} foo \{{[\}}" +f"\{3}" +rf"\{"a"}" diff --git a/tests/data/cases/pep_750.py b/tests/data/cases/pep_750.py new file mode 100644 index 0000000..ca99211 --- /dev/null +++ b/tests/data/cases/pep_750.py @@ -0,0 +1,83 @@ +# flags: --minimum-version=3.14 +x = t"foo" +x = t'foo {{ {2 + 2}bar {{ baz' + +x = t"foo {f'abc'} bar" + +x = t"""foo {{ a + foo {2 + 2}bar {{ baz + + x = f"foo {{ { + 2 + 2 # comment + }bar" + + {{ baz + + }} buzz + + {print("abc" + "def" +)} +abc""" + +t'{(abc:=10)}' + +t'''This is a really long string, but just make sure that you reflow tstrings { + 2+2:d +}''' +t'This is a really long string, but just make sure that you reflow tstrings correctly {2+2:d}' + +t"{ 2 + 2 = }" + +t'{ +X +!r +}' + +tr'\{{\}}' + +t''' + WITH {f''' + {1}_cte AS ()'''} +''' + +# output +x = t"foo" +x = t"foo {{ {2 + 2}bar {{ baz" + +x = t"foo {f'abc'} bar" + +x = t"""foo {{ a + foo {2 + 2}bar {{ baz + + x = f"foo {{ { + 2 + 2 # comment + }bar" + + {{ baz + + }} buzz + + {print("abc" + "def" +)} +abc""" + +t"{(abc:=10)}" + +t"""This is a really long string, but just make sure that you reflow tstrings { + 2+2:d +}""" +t"This is a really long string, but just make sure that you reflow tstrings correctly {2+2:d}" + +t"{ 2 + 2 = }" + +t"{ +X +!r +}" + +rt"\{{\}}" + +t""" + WITH {f''' + {1}_cte AS ()'''} +""" diff --git a/tests/data/cases/percent_precedence.py b/tests/data/cases/percent_precedence.py new file mode 100644 index 0000000..7822e42 --- /dev/null +++ b/tests/data/cases/percent_precedence.py @@ -0,0 +1,41 @@ +("" % a) ** 2 +("" % a)[0] +("" % a)() +("" % a).b + +2 * ("" % a) +2 @ ("" % a) +2 / ("" % a) +2 // ("" % a) +2 % ("" % a) ++("" % a) +b + ("" % a) +-("" % a) +b - ("" % a) +b + -("" % a) +~("" % a) +2 ** ("" % a) +await ("" % a) +b[("" % a)] +b(("" % a)) +# output +("" % a) ** 2 +("" % a)[0] +("" % a)() +("" % a).b + +2 * ("" % a) +2 @ ("" % a) +2 / ("" % a) +2 // ("" % a) +2 % ("" % a) ++("" % a) +b + ("" % a) +-("" % a) +b - ("" % a) +b + -("" % a) +~("" % a) +2 ** ("" % a) +await ("" % a) +b[("" % a)] +b(("" % a)) diff --git a/tests/data/cases/power_op_newline.py b/tests/data/cases/power_op_newline.py new file mode 100644 index 0000000..d9b3140 --- /dev/null +++ b/tests/data/cases/power_op_newline.py @@ -0,0 +1,11 @@ +# flags: --line-length=0 +importA;()<<0**0# + +# output + +importA +( + () + << 0 + ** 0 +) # diff --git a/tests/data/cases/power_op_spacing.py b/tests/data/cases/power_op_spacing.py new file mode 100644 index 0000000..b3ef0aa --- /dev/null +++ b/tests/data/cases/power_op_spacing.py @@ -0,0 +1,149 @@ +def function(**kwargs): + t = a**2 + b**3 + return t ** 2 + + +def function_replace_spaces(**kwargs): + t = a **2 + b** 3 + c ** 4 + + +def function_dont_replace_spaces(): + {**a, **b, **c} + + +a = 5**~4 +b = 5 ** f() +c = -(5**2) +d = 5 ** f["hi"] +e = lazy(lambda **kwargs: 5) +f = f() ** 5 +g = a.b**c.d +h = 5 ** funcs.f() +i = funcs.f() ** 5 +j = super().name ** 5 +k = [(2**idx, value) for idx, value in pairs] +l = mod.weights_[0] == pytest.approx(0.95**100, abs=0.001) +m = [([2**63], [1, 2**63])] +n = count <= 10**5 +o = settings(max_examples=10**6) +p = {(k, k**2): v**2 for k, v in pairs} +q = [10**i for i in range(6)] +r = x**y +s = 1 ** 1 +t = ( + 1 + ** 1 + **1 + ** 1 +) + +a = 5.0**~4.0 +b = 5.0 ** f() +c = -(5.0**2.0) +d = 5.0 ** f["hi"] +e = lazy(lambda **kwargs: 5) +f = f() ** 5.0 +g = a.b**c.d +h = 5.0 ** funcs.f() +i = funcs.f() ** 5.0 +j = super().name ** 5.0 +k = [(2.0**idx, value) for idx, value in pairs] +l = mod.weights_[0] == pytest.approx(0.95**100, abs=0.001) +m = [([2.0**63.0], [1.0, 2**63.0])] +n = count <= 10**5.0 +o = settings(max_examples=10**6.0) +p = {(k, k**2): v**2.0 for k, v in pairs} +q = [10.5**i for i in range(6)] +s = 1.0 ** 1.0 +t = ( + 1.0 + ** 1.0 + **1.0 + ** 1.0 +) + + +# WE SHOULD DEFINITELY NOT EAT THESE COMMENTS (https://github.com/psf/black/issues/2873) +if hasattr(view, "sum_of_weights"): + return np.divide( # type: ignore[no-any-return] + view.variance, # type: ignore[union-attr] + view.sum_of_weights, # type: ignore[union-attr] + out=np.full(view.sum_of_weights.shape, np.nan), # type: ignore[union-attr] + where=view.sum_of_weights**2 > view.sum_of_weights_squared, # type: ignore[union-attr] + ) + +return np.divide( + where=view.sum_of_weights_of_weight_long**2 > view.sum_of_weights_squared, # type: ignore +) + + +# output + + +def function(**kwargs): + t = a**2 + b**3 + return t**2 + + +def function_replace_spaces(**kwargs): + t = a**2 + b**3 + c**4 + + +def function_dont_replace_spaces(): + {**a, **b, **c} + + +a = 5**~4 +b = 5 ** f() +c = -(5**2) +d = 5 ** f["hi"] +e = lazy(lambda **kwargs: 5) +f = f() ** 5 +g = a.b**c.d +h = 5 ** funcs.f() +i = funcs.f() ** 5 +j = super().name ** 5 +k = [(2**idx, value) for idx, value in pairs] +l = mod.weights_[0] == pytest.approx(0.95**100, abs=0.001) +m = [([2**63], [1, 2**63])] +n = count <= 10**5 +o = settings(max_examples=10**6) +p = {(k, k**2): v**2 for k, v in pairs} +q = [10**i for i in range(6)] +r = x**y +s = 1**1 +t = 1**1**1**1 + +a = 5.0**~4.0 +b = 5.0 ** f() +c = -(5.0**2.0) +d = 5.0 ** f["hi"] +e = lazy(lambda **kwargs: 5) +f = f() ** 5.0 +g = a.b**c.d +h = 5.0 ** funcs.f() +i = funcs.f() ** 5.0 +j = super().name ** 5.0 +k = [(2.0**idx, value) for idx, value in pairs] +l = mod.weights_[0] == pytest.approx(0.95**100, abs=0.001) +m = [([2.0**63.0], [1.0, 2**63.0])] +n = count <= 10**5.0 +o = settings(max_examples=10**6.0) +p = {(k, k**2): v**2.0 for k, v in pairs} +q = [10.5**i for i in range(6)] +s = 1.0**1.0 +t = 1.0**1.0**1.0**1.0 + + +# WE SHOULD DEFINITELY NOT EAT THESE COMMENTS (https://github.com/psf/black/issues/2873) +if hasattr(view, "sum_of_weights"): + return np.divide( # type: ignore[no-any-return] + view.variance, # type: ignore[union-attr] + view.sum_of_weights, # type: ignore[union-attr] + out=np.full(view.sum_of_weights.shape, np.nan), # type: ignore[union-attr] + where=view.sum_of_weights**2 > view.sum_of_weights_squared, # type: ignore[union-attr] + ) + +return np.divide( + where=view.sum_of_weights_of_weight_long**2 > view.sum_of_weights_squared, # type: ignore +) diff --git a/tests/data/cases/power_op_spacing_long.py b/tests/data/cases/power_op_spacing_long.py new file mode 100644 index 0000000..30e6eb7 --- /dev/null +++ b/tests/data/cases/power_op_spacing_long.py @@ -0,0 +1,96 @@ +a = 1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1 +b = 1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1 +c = 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 +d = 1**1 ** 1**1 ** 1**1 ** 1**1 ** 1**1**1 ** 1 ** 1**1 ** 1**1**1**1**1 ** 1 ** 1**1**1 **1**1** 1 ** 1 ** 1 +e = 𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟 +f = 𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟 + +a = 1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0 +b = 1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0 +c = 1.0 ** 1.0 ** 1.0 ** 1.0 ** 1.0 ** 1.0 ** 1.0 ** 1.0 ** 1.0 ** 1.0 ** 1.0 ** 1.0 ** 1.0 ** 1.0 ** 1.0 ** 1.0 ** 1.0 +d = 1.0**1.0 ** 1.0**1.0 ** 1.0**1.0 ** 1.0**1.0 ** 1.0**1.0**1.0 ** 1.0 ** 1.0**1.0 ** 1.0**1.0**1.0 + +# output +a = 1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1 +b = ( + 1 + ** 1 + ** 1 + ** 1 + ** 1 + ** 1 + ** 1 + ** 1 + ** 1 + ** 1 + ** 1 + ** 1 + ** 1 + ** 1 + ** 1 + ** 1 + ** 1 + ** 1 + ** 1 + ** 1 + ** 1 + ** 1 + ** 1 + ** 1 + ** 1 + ** 1 + ** 1 + ** 1 + ** 1 +) +c = 1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1 +d = 1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1 +e = 𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟 +f = ( + 𨉟 + ** 𨉟 + ** 𨉟 + ** 𨉟 + ** 𨉟 + ** 𨉟 + ** 𨉟 + ** 𨉟 + ** 𨉟 + ** 𨉟 + ** 𨉟 + ** 𨉟 + ** 𨉟 + ** 𨉟 + ** 𨉟 + ** 𨉟 + ** 𨉟 + ** 𨉟 + ** 𨉟 + ** 𨉟 + ** 𨉟 + ** 𨉟 +) + +a = 1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0 +b = ( + 1.0 + ** 1.0 + ** 1.0 + ** 1.0 + ** 1.0 + ** 1.0 + ** 1.0 + ** 1.0 + ** 1.0 + ** 1.0 + ** 1.0 + ** 1.0 + ** 1.0 + ** 1.0 + ** 1.0 + ** 1.0 + ** 1.0 + ** 1.0 +) +c = 1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0 +d = 1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0 diff --git a/tests/data/cases/prefer_rhs_split.py b/tests/data/cases/prefer_rhs_split.py new file mode 100644 index 0000000..0dde9a1 --- /dev/null +++ b/tests/data/cases/prefer_rhs_split.py @@ -0,0 +1,118 @@ +first_item, second_item = ( + some_looooooooong_module.some_looooooooooooooong_function_name( + first_argument, second_argument, third_argument + ) +) + +some_dict["with_a_long_key"] = ( + some_looooooooong_module.some_looooooooooooooong_function_name( + first_argument, second_argument, third_argument + ) +) + +# Make sure it works when the RHS only has one pair of (optional) parens. +first_item, second_item = ( + some_looooooooong_module.SomeClass.some_looooooooooooooong_variable_name +) + +some_dict["with_a_long_key"] = ( + some_looooooooong_module.SomeClass.some_looooooooooooooong_variable_name +) + +# Make sure chaining assignments work. +first_item, second_item, third_item, forth_item = m["everything"] = ( + some_looooooooong_module.some_looooooooooooooong_function_name( + first_argument, second_argument, third_argument + ) +) + +# Make sure when the RHS's first split at the non-optional paren fits, +# we split there instead of the outer RHS optional paren. +first_item, second_item = some_looooooooong_module.some_loooooog_function_name( + first_argument, second_argument, third_argument +) + +( + first_item, + second_item, + third_item, + forth_item, + fifth_item, + last_item_very_loooooong, +) = some_looooooooong_module.some_looooooooooooooong_function_name( + first_argument, second_argument, third_argument +) + +( + first_item, + second_item, + third_item, + forth_item, + fifth_item, + last_item_very_loooooong, +) = everything = some_looooong_function_name( + first_argument, second_argument, third_argument +) + + +# Make sure unsplittable type ignore won't be moved. +some_kind_of_table[some_key] = util.some_function( # type: ignore # noqa: E501 + some_arg +).intersection(pk_cols) + +some_kind_of_table[ + some_key +] = lambda obj: obj.some_long_named_method() # type: ignore # noqa: E501 + +some_kind_of_table[ + some_key # type: ignore # noqa: E501 +] = lambda obj: obj.some_long_named_method() + + +# Make when when the left side of assignment plus the opening paren "... = (" is +# exactly line length limit + 1, it won't be split like that. +xxxxxxxxx_yyy_zzzzzzzz[ + xx.xxxxxx(x_yyy_zzzzzz.xxxxx[0]), x_yyy_zzzzzz.xxxxxx(xxxx=1) +] = 1 + + +# Right side of assignment contains un-nested pairs of inner parens. +some_kind_of_instance.some_kind_of_map[a_key] = ( + isinstance(some_var, SomeClass) + and table.something_and_something != table.something_else +) or ( + isinstance(some_other_var, BaseClass) and table.something != table.some_other_thing +) + +# Multiple targets +a = b = ( + ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc +) + +a = b = c = d = e = f = g = ( + hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh +) = i = j = ( + kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk +) + +a = ( + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +) = c + +a = ( + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +) = ( + cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc +) = ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd + + +# Make sure that when the RHS contains a subscript access chain (attribute +# access with subscript like obj.children[idx].attr), Black prefers wrapping +# the RHS in parentheses rather than splitting at the subscript. +some_node.children[1].prefix = ( + some_node.children[0].prefix + some_node.children[1].prefix +) + +another_node.children[idx].value = ( + another_node.children[idx - 1].value + another_node.children[idx + 1].value +) diff --git a/tests/data/cases/prefer_rhs_split_reformatted.py b/tests/data/cases/prefer_rhs_split_reformatted.py new file mode 100644 index 0000000..0c0076b --- /dev/null +++ b/tests/data/cases/prefer_rhs_split_reformatted.py @@ -0,0 +1,71 @@ +# Test cases separate from `prefer_rhs_split.py` that contains unformatted source. + +# Left hand side fits in a single line but will still be exploded by the +# magic trailing comma. +first_value, (m1, m2,), third_value = xxxxxx_yyyyyy_zzzzzz_wwwwww_uuuuuuu_vvvvvvvvvvv( + arg1, + arg2, +) + +# Make when when the left side of assignment plus the opening paren "... = (" is +# exactly line length limit + 1, it won't be split like that. +xxxxxxxxx_yyy_zzzzzzzz[xx.xxxxxx(x_yyy_zzzzzz.xxxxx[0]), x_yyy_zzzzzz.xxxxxx(xxxx=1)] = 1 + +# Regression test for #1187 +print( + dict( + a=1, + b=2 if some_kind_of_data is not None else some_other_kind_of_data, # some explanation of why this is actually necessary + c=3, + ) +) + +# Regression: subscript access chain on RHS should not be split mid-chain +some_node.children[1].prefix = some_node.children[0].prefix + some_node.children[1].prefix + +another_node.children[idx].value = another_node.children[idx - 1].value + another_node.children[idx + 1].value + +# output + + +# Test cases separate from `prefer_rhs_split.py` that contains unformatted source. + +# Left hand side fits in a single line but will still be exploded by the +# magic trailing comma. +( + first_value, + ( + m1, + m2, + ), + third_value, +) = xxxxxx_yyyyyy_zzzzzz_wwwwww_uuuuuuu_vvvvvvvvvvv( + arg1, + arg2, +) + +# Make when when the left side of assignment plus the opening paren "... = (" is +# exactly line length limit + 1, it won't be split like that. +xxxxxxxxx_yyy_zzzzzzzz[ + xx.xxxxxx(x_yyy_zzzzzz.xxxxx[0]), x_yyy_zzzzzz.xxxxxx(xxxx=1) +] = 1 + +# Regression test for #1187 +print( + dict( + a=1, + b=( + 2 if some_kind_of_data is not None else some_other_kind_of_data + ), # some explanation of why this is actually necessary + c=3, + ) +) + +# Regression: subscript access chain on RHS should not be split mid-chain +some_node.children[1].prefix = ( + some_node.children[0].prefix + some_node.children[1].prefix +) + +another_node.children[idx].value = ( + another_node.children[idx - 1].value + another_node.children[idx + 1].value +) diff --git a/tests/data/cases/preview_cantfit_string.py b/tests/data/cases/preview_cantfit_string.py new file mode 100644 index 0000000..3b48e31 --- /dev/null +++ b/tests/data/cases/preview_cantfit_string.py @@ -0,0 +1,18 @@ +# flags: --unstable +# long arguments +normal_name = normal_function_name( + "but with super long string arguments that on their own exceed the line limit so there's no way it can ever fit", + "eggs with spam and eggs and spam with eggs with spam and eggs and spam with eggs with spam and eggs and spam with eggs", + this_is_a_ridiculously_long_name_and_nobody_in_their_right_mind_would_use_one_like_it=0, +) + +# output + +# long arguments +normal_name = normal_function_name( + "but with super long string arguments that on their own exceed the line limit so" + " there's no way it can ever fit", + "eggs with spam and eggs and spam with eggs with spam and eggs and spam with eggs" + " with spam and eggs and spam with eggs", + this_is_a_ridiculously_long_name_and_nobody_in_their_right_mind_would_use_one_like_it=0, +) diff --git a/tests/data/cases/preview_comments7.py b/tests/data/cases/preview_comments7.py new file mode 100644 index 0000000..703e3c8 --- /dev/null +++ b/tests/data/cases/preview_comments7.py @@ -0,0 +1,308 @@ +# flags: --unstable +from .config import ( + Any, + Bool, + ConfigType, + ConfigTypeAttributes, + Int, + Path, + # String, + # resolve_to_config_type, + # DEFAULT_TYPE_ATTRIBUTES, +) + + +from .config import ( + Any, + Bool, + ConfigType, + ConfigTypeAttributes, + Int, + no_comma_here_yet + # and some comments, + # resolve_to_config_type, + # DEFAULT_TYPE_ATTRIBUTES, +) +from com.my_lovely_company.my_lovely_team.my_lovely_project.my_lovely_component import ( + MyLovelyCompanyTeamProjectComponent # NOT DRY +) +from com.my_lovely_company.my_lovely_team.my_lovely_project.my_lovely_component import ( + MyLovelyCompanyTeamProjectComponent as component # DRY +) + + +result = 1 # look ma, no comment migration xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx + +result = ( + 1 # look ma, no comment migration xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +) + +result = ( + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" # aaa +) + +result = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" # aaa + + +def func(): + c = call( + 0.0123, + 0.0456, + 0.0789, + 0.0123, + 0.0789, + a[-1], # type: ignore + ) + c = call( + 0.0123, + 0.0456, + 0.0789, + 0.0123, + 0.0789, + a[-1] # type: ignore + ) + c = call( + 0.0123, + 0.0456, + 0.0789, + 0.0123, + 0.0456, + 0.0789, + 0.0123, + 0.0456, + 0.0789, + a[-1] # type: ignore + ) + + # The type: ignore exception only applies to line length, not + # other types of formatting. + c = call( + "aaaaaaaa", "aaaaaaaa", "aaaaaaaa", "aaaaaaaa", "aaaaaaaa", "aaaaaaaa", # type: ignore + "aaaaaaaa", "aaaaaaaa", "aaaaaaaa", "aaaaaaaa", "aaaaaaaa", "aaaaaaaa" + ) + + +class C: + @pytest.mark.parametrize( + ("post_data", "message"), + [ + # metadata_version errors. + ( + {}, + "None is an invalid value for Metadata-Version. Error: This field is" + " required. see" + " https://packaging.python.org/specifications/core-metadata" + ), + ( + {"metadata_version": "-1"}, + "'-1' is an invalid value for Metadata-Version. Error: Unknown Metadata" + " Version see" + " https://packaging.python.org/specifications/core-metadata" + ), + # name errors. + ( + {"metadata_version": "1.2"}, + "'' is an invalid value for Name. Error: This field is required. see" + " https://packaging.python.org/specifications/core-metadata" + ), + ( + {"metadata_version": "1.2", "name": "foo-"}, + "'foo-' is an invalid value for Name. Error: Must start and end with a" + " letter or numeral and contain only ascii numeric and '.', '_' and" + " '-'. see https://packaging.python.org/specifications/core-metadata" + ), + # version errors. + ( + {"metadata_version": "1.2", "name": "example"}, + "'' is an invalid value for Version. Error: This field is required. see" + " https://packaging.python.org/specifications/core-metadata" + ), + ( + {"metadata_version": "1.2", "name": "example", "version": "dog"}, + "'dog' is an invalid value for Version. Error: Must start and end with" + " a letter or numeral and contain only ascii numeric and '.', '_' and" + " '-'. see https://packaging.python.org/specifications/core-metadata" + ) + ] + ) + def test_fails_invalid_post_data( + self, pyramid_config, db_request, post_data, message + ): + ... + +square = Square(4) # type: Optional[Square] + +# Regression test for https://github.com/psf/black/issues/3756. +[ + ( + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" # aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + ), +] +[ + ( # aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" # aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + ), +] + +# output + +from .config import ( + Any, + Bool, + ConfigType, + ConfigTypeAttributes, + Int, + Path, + # String, + # resolve_to_config_type, + # DEFAULT_TYPE_ATTRIBUTES, +) + + +from .config import ( + Any, + Bool, + ConfigType, + ConfigTypeAttributes, + Int, + no_comma_here_yet, + # and some comments, + # resolve_to_config_type, + # DEFAULT_TYPE_ATTRIBUTES, +) +from com.my_lovely_company.my_lovely_team.my_lovely_project.my_lovely_component import ( + MyLovelyCompanyTeamProjectComponent, # NOT DRY +) +from com.my_lovely_company.my_lovely_team.my_lovely_project.my_lovely_component import ( + MyLovelyCompanyTeamProjectComponent as component, # DRY +) + +result = 1 # look ma, no comment migration xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx + +result = 1 # look ma, no comment migration xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx + +result = ( # aaa + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +) + +result = ( # aaa + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +) + + +def func(): + c = call( + 0.0123, + 0.0456, + 0.0789, + 0.0123, + 0.0789, + a[-1], # type: ignore + ) + c = call(0.0123, 0.0456, 0.0789, 0.0123, 0.0789, a[-1]) # type: ignore + c = call( + 0.0123, + 0.0456, + 0.0789, + 0.0123, + 0.0456, + 0.0789, + 0.0123, + 0.0456, + 0.0789, + a[-1], # type: ignore + ) + + # The type: ignore exception only applies to line length, not + # other types of formatting. + c = call( + "aaaaaaaa", + "aaaaaaaa", + "aaaaaaaa", + "aaaaaaaa", + "aaaaaaaa", + "aaaaaaaa", # type: ignore + "aaaaaaaa", + "aaaaaaaa", + "aaaaaaaa", + "aaaaaaaa", + "aaaaaaaa", + "aaaaaaaa", + ) + + +class C: + @pytest.mark.parametrize( + ("post_data", "message"), + [ + # metadata_version errors. + ( + {}, + ( + "None is an invalid value for Metadata-Version. Error: This field" + " is required. see" + " https://packaging.python.org/specifications/core-metadata" + ), + ), + ( + {"metadata_version": "-1"}, + ( + "'-1' is an invalid value for Metadata-Version. Error: Unknown" + " Metadata Version see" + " https://packaging.python.org/specifications/core-metadata" + ), + ), + # name errors. + ( + {"metadata_version": "1.2"}, + ( + "'' is an invalid value for Name. Error: This field is required." + " see https://packaging.python.org/specifications/core-metadata" + ), + ), + ( + {"metadata_version": "1.2", "name": "foo-"}, + ( + "'foo-' is an invalid value for Name. Error: Must start and end" + " with a letter or numeral and contain only ascii numeric and '.'," + " '_' and '-'. see" + " https://packaging.python.org/specifications/core-metadata" + ), + ), + # version errors. + ( + {"metadata_version": "1.2", "name": "example"}, + ( + "'' is an invalid value for Version. Error: This field is required." + " see https://packaging.python.org/specifications/core-metadata" + ), + ), + ( + {"metadata_version": "1.2", "name": "example", "version": "dog"}, + ( + "'dog' is an invalid value for Version. Error: Must start and end" + " with a letter or numeral and contain only ascii numeric and '.'," + " '_' and '-'. see" + " https://packaging.python.org/specifications/core-metadata" + ), + ), + ], + ) + def test_fails_invalid_post_data( + self, pyramid_config, db_request, post_data, message + ): ... + + +square = Square(4) # type: Optional[Square] + +# Regression test for https://github.com/psf/black/issues/3756. +[ + ( # aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + ), +] +[ + ( # aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" # aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + ), +] diff --git a/tests/data/cases/preview_fstring.py b/tests/data/cases/preview_fstring.py new file mode 100644 index 0000000..e0a3eac --- /dev/null +++ b/tests/data/cases/preview_fstring.py @@ -0,0 +1,2 @@ +# flags: --unstable +f"{''=}" f'{""=}' \ No newline at end of file diff --git a/tests/data/cases/preview_hug_comparator.py b/tests/data/cases/preview_hug_comparator.py new file mode 100644 index 0000000..a5f7aeb --- /dev/null +++ b/tests/data/cases/preview_hug_comparator.py @@ -0,0 +1,134 @@ +# flags: --preview --line-length=88 + +# Regression test for https://github.com/psf/black/issues/4514 +# Black used to split between a variable and its comparator (`if t / not in`) +# whenever the RHS was a bracketed expression that had to break. With the fix, +# the comparator stays attached to its left operand and the bracket explodes +# instead. The same shape appears outside comprehensions (inside `if`/`elif`, +# `assert`, parenthesized expressions, etc.) and is fixed in all of them. + +# Comprehension `if` with a magic-trailing-comma set on the RHS. This is the +# original case from the issue. +x = [ + t + for t in y + if t not in {LongNameOne, LongNameTwo, LongNameThree,} +] + +# Different comparator (`<`) and a magic-trailing-comma call on the RHS. +ranked = [ + t + for t in y + if t < SomeFunction(LongNameOne, LongNameTwo, LongNameThree,) +] + +# Boolean operator before the comparator: the `or` splits, and the remaining +# `t in {...,}` defers to the bracket explosion instead of splitting at `in`. +combined = [ + t + for t in y + if some_short_predicate or t in {LongNameOne, LongNameTwo, LongNameThree,} +] + +# No magic trailing comma: the RHS is long enough that Black has to break it +# anyway. The comparator should stay with `if t`. +no_magic = [ + t + for t in y + if t not in some_very_long_function_name(argument_one, argument_two, argument_three, argument_four) +] + +# `if` inside an `and` chain with a magic-trailing-comma tuple on the RHS. +if ( + is_scalar(value) + and self.dtype in (np.dtype("float64"), np.dtype("float32"), np.dtype("object"),) + and (limit is not None or inplace) +): + do_thing() + +# `assert` with `is` and a call-chain RHS that has to break. +assert ( + bool is _AnnotationExtractor(attr.fields(C).x.converter.__call__).get_return_type() +) + +# `assert` with `in` and a chained call as RHS. +assert ( + f"{existing_section}\n{init_basic_toml_no_readme}" in pyproject_file.read_text(encoding="utf-8") +) + +# output + +# Regression test for https://github.com/psf/black/issues/4514 +# Black used to split between a variable and its comparator (`if t / not in`) +# whenever the RHS was a bracketed expression that had to break. With the fix, +# the comparator stays attached to its left operand and the bracket explodes +# instead. The same shape appears outside comprehensions (inside `if`/`elif`, +# `assert`, parenthesized expressions, etc.) and is fixed in all of them. + +# Comprehension `if` with a magic-trailing-comma set on the RHS. This is the +# original case from the issue. +x = [ + t + for t in y + if t not in { + LongNameOne, + LongNameTwo, + LongNameThree, + } +] + +# Different comparator (`<`) and a magic-trailing-comma call on the RHS. +ranked = [ + t + for t in y + if t < SomeFunction( + LongNameOne, + LongNameTwo, + LongNameThree, + ) +] + +# Boolean operator before the comparator: the `or` splits, and the remaining +# `t in {...,}` defers to the bracket explosion instead of splitting at `in`. +combined = [ + t + for t in y + if some_short_predicate + or t in { + LongNameOne, + LongNameTwo, + LongNameThree, + } +] + +# No magic trailing comma: the RHS is long enough that Black has to break it +# anyway. The comparator should stay with `if t`. +no_magic = [ + t + for t in y + if t not in some_very_long_function_name( + argument_one, argument_two, argument_three, argument_four + ) +] + +# `if` inside an `and` chain with a magic-trailing-comma tuple on the RHS. +if ( + is_scalar(value) + and self.dtype in ( + np.dtype("float64"), + np.dtype("float32"), + np.dtype("object"), + ) + and (limit is not None or inplace) +): + do_thing() + +# `assert` with `is` and a call-chain RHS that has to break. +assert ( + bool is _AnnotationExtractor(attr.fields(C).x.converter.__call__).get_return_type() +) + +# `assert` with `in` and a chained call as RHS. +assert f"{existing_section}\n{init_basic_toml_no_readme}" in pyproject_file.read_text( + encoding="utf-8" +) diff --git a/tests/data/cases/preview_hug_parens_with_braces_and_square_brackets.py b/tests/data/cases/preview_hug_parens_with_braces_and_square_brackets.py new file mode 100644 index 0000000..cbbcf16 --- /dev/null +++ b/tests/data/cases/preview_hug_parens_with_braces_and_square_brackets.py @@ -0,0 +1,347 @@ +# flags: --unstable +def foo_brackets(request): + return JsonResponse( + { + "var_1": foo, + "var_2": bar, + } + ) + +def foo_square_brackets(request): + return JsonResponse( + [ + "var_1", + "var_2", + ] + ) + +func({"a": 37, "b": 42, "c": 927, "aaaaaaaaaaaaaaaaaaaaaaaaa": 11111111111111111111111111111111111111111}) + +func(["random_string_number_one","random_string_number_two","random_string_number_three","random_string_number_four"]) + +func( + { + # expand me + 'a':37, + 'b':42, + 'c':927 + } +) + +func( + [ + 'a', + 'b', + 'c', + ] +) + +func( + [ + 'a', + 'b', + 'c', + ], +) + +func( # a + [ # b + "c", # c + "d", # d + "e", # e + ] # f +) # g + +func( # a + { # b + "c": 1, # c + "d": 2, # d + "e": 3, # e + } # f +) # g + +func( + # preserve me + [ + "c", + "d", + "e", + ] +) + +func( + [ # preserve me but hug brackets + "c", + "d", + "e", + ] +) + +func( + [ + # preserve me but hug brackets + "c", + "d", + "e", + ] +) + +func( + [ + "c", + # preserve me but hug brackets + "d", + "e", + ] +) + +func( + [ + "c", + "d", + "e", + # preserve me but hug brackets + ] +) + +func( + [ + "c", + "d", + "e", + ] # preserve me but hug brackets +) + +func( + [ + "c", + "d", + "e", + ] + # preserve me +) + +func([x for x in "short line"]) +func([x for x in "long line long line long line long line long line long line long line"]) +func([x for x in [x for x in "long line long line long line long line long line long line long line"]]) + +foooooooooooooooooooo( + [{c: n + 1 for c in range(256)} for n in range(100)] + [{}], {size} +) + +baaaaaaaaaaaaar( + [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], {x}, "a string", [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] +) + +nested_mapping = {"key": [{"a very long key 1": "with a very long value", "a very long key 2": "with a very long value"}]} +explicit_exploding = [[["short", "line",],],] +single_item_do_not_explode = Context({ + "version": get_docs_version(), +}) + +foo(*[str(i) for i in range(100000000000000000000000000000000000000000000000000000000000)]) + +foo( + **{ + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa": 1, + "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb": 2, + "ccccccccccccccccccccccccccccccccc": 3, + **other, + } +) + +foo(**{x: y for x, y in enumerate(["long long long long line","long long long long line"])}) + +# Edge case when deciding whether to hug the brackets without inner content. +very_very_very_long_variable = very_very_very_long_module.VeryVeryVeryVeryLongClassName([[]]) + +for foo in ["a", "b"]: + output.extend([ + individual + for + # Foobar + container in xs_by_y[foo] + # Foobar + for individual in container["nested"] + ]) + +# output +def foo_brackets(request): + return JsonResponse({ + "var_1": foo, + "var_2": bar, + }) + + +def foo_square_brackets(request): + return JsonResponse([ + "var_1", + "var_2", + ]) + + +func({ + "a": 37, + "b": 42, + "c": 927, + "aaaaaaaaaaaaaaaaaaaaaaaaa": 11111111111111111111111111111111111111111, +}) + +func([ + "random_string_number_one", + "random_string_number_two", + "random_string_number_three", + "random_string_number_four", +]) + +func({ + # expand me + "a": 37, + "b": 42, + "c": 927, +}) + +func([ + "a", + "b", + "c", +]) + +func( + [ + "a", + "b", + "c", + ], +) + +func([ # a # b + "c", # c + "d", # d + "e", # e +]) # f # g + +func({ # a # b + "c": 1, # c + "d": 2, # d + "e": 3, # e +}) # f # g + +func( + # preserve me + [ + "c", + "d", + "e", + ] +) + +func([ # preserve me but hug brackets + "c", + "d", + "e", +]) + +func([ + # preserve me but hug brackets + "c", + "d", + "e", +]) + +func([ + "c", + # preserve me but hug brackets + "d", + "e", +]) + +func([ + "c", + "d", + "e", + # preserve me but hug brackets +]) + +func([ + "c", + "d", + "e", +]) # preserve me but hug brackets + +func( + [ + "c", + "d", + "e", + ] + # preserve me +) + +func([x for x in "short line"]) +func( + [x for x in "long line long line long line long line long line long line long line"] +) +func([ + x + for x in [ + x + for x in "long line long line long line long line long line long line long line" + ] +]) + +foooooooooooooooooooo( + [{c: n + 1 for c in range(256)} for n in range(100)] + [{}], {size} +) + +baaaaaaaaaaaaar( + [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], {x}, "a string", [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] +) + +nested_mapping = { + "key": [{ + "a very long key 1": "with a very long value", + "a very long key 2": "with a very long value", + }] +} +explicit_exploding = [ + [ + [ + "short", + "line", + ], + ], +] +single_item_do_not_explode = Context({ + "version": get_docs_version(), +}) + +foo(*[ + str(i) for i in range(100000000000000000000000000000000000000000000000000000000000) +]) + +foo(**{ + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa": 1, + "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb": 2, + "ccccccccccccccccccccccccccccccccc": 3, + **other, +}) + +foo(**{ + x: y for x, y in enumerate(["long long long long line", "long long long long line"]) +}) + +# Edge case when deciding whether to hug the brackets without inner content. +very_very_very_long_variable = very_very_very_long_module.VeryVeryVeryVeryLongClassName( + [[]] +) + +for foo in ["a", "b"]: + output.extend([ + individual + for + # Foobar + container in xs_by_y[foo] + # Foobar + for individual in container["nested"] + ]) diff --git a/tests/data/cases/preview_hug_parens_with_braces_and_square_brackets_no_ll1.py b/tests/data/cases/preview_hug_parens_with_braces_and_square_brackets_no_ll1.py new file mode 100644 index 0000000..16ebea3 --- /dev/null +++ b/tests/data/cases/preview_hug_parens_with_braces_and_square_brackets_no_ll1.py @@ -0,0 +1,106 @@ +# flags: --unstable --no-preview-line-length-1 +# split out from preview_hug_parens_with_brackes_and_square_brackets, as it produces +# different code on the second pass with line-length 1 in many cases. +# Seems to be about whether the last string in a sequence gets wrapped in parens or not. +foo(*["long long long long long line", "long long long long long line", "long long long long long line"]) +func({"short line"}) +func({"long line", "long long line", "long long long line", "long long long long line", "long long long long long line"}) +func({{"long line", "long long line", "long long long line", "long long long long line", "long long long long long line"}}) +func(("long line", "long long line", "long long long line", "long long long long line", "long long long long long line")) +func((("long line", "long long line", "long long long line", "long long long long line", "long long long long long line"))) +func([["long line", "long long line", "long long long line", "long long long long line", "long long long long long line"]]) + + +# Do not hug if the argument fits on a single line. +func({"fit line", "fit line", "fit line", "fit line", "fit line", "fit line", "fit line"}) +func(("fit line", "fit line", "fit line", "fit line", "fit line", "fit line", "fit line")) +func(["fit line", "fit line", "fit line", "fit line", "fit line", "fit line", "fit line"]) +func(**{"fit line", "fit line", "fit line", "fit line", "fit line", "fit line", "fit---"}) +func(*("fit line", "fit line", "fit line", "fit line", "fit line", "fit line", "fit----")) +array = [{"fit line", "fit line", "fit line", "fit line", "fit line", "fit line", "fit line"}] +array = [("fit line", "fit line", "fit line", "fit line", "fit line", "fit line", "fit line")] +array = [["fit line", "fit line", "fit line", "fit line", "fit line", "fit line", "fit line"]] + +nested_array = [[["long line", "long long line", "long long long line", "long long long long line", "long long long long long line"]]] + +# output + +# split out from preview_hug_parens_with_brackes_and_square_brackets, as it produces +# different code on the second pass with line-length 1 in many cases. +# Seems to be about whether the last string in a sequence gets wrapped in parens or not. +foo(*[ + "long long long long long line", + "long long long long long line", + "long long long long long line", +]) +func({"short line"}) +func({ + "long line", + "long long line", + "long long long line", + "long long long long line", + "long long long long long line", +}) +func({{ + "long line", + "long long line", + "long long long line", + "long long long long line", + "long long long long long line", +}}) +func(( + "long line", + "long long line", + "long long long line", + "long long long long line", + "long long long long long line", +)) +func((( + "long line", + "long long line", + "long long long line", + "long long long long line", + "long long long long long line", +))) +func([[ + "long line", + "long long line", + "long long long line", + "long long long long line", + "long long long long long line", +]]) + + +# Do not hug if the argument fits on a single line. +func( + {"fit line", "fit line", "fit line", "fit line", "fit line", "fit line", "fit line"} +) +func( + ("fit line", "fit line", "fit line", "fit line", "fit line", "fit line", "fit line") +) +func( + ["fit line", "fit line", "fit line", "fit line", "fit line", "fit line", "fit line"] +) +func( + **{"fit line", "fit line", "fit line", "fit line", "fit line", "fit line", "fit---"} +) +func( + *("fit line", "fit line", "fit line", "fit line", "fit line", "fit line", "fit----") +) +array = [ + {"fit line", "fit line", "fit line", "fit line", "fit line", "fit line", "fit line"} +] +array = [ + ("fit line", "fit line", "fit line", "fit line", "fit line", "fit line", "fit line") +] +array = [ + ["fit line", "fit line", "fit line", "fit line", "fit line", "fit line", "fit line"] +] + +nested_array = [[[ + "long line", + "long long line", + "long long long line", + "long long long long line", + "long long long long long line", +]]] diff --git a/tests/data/cases/preview_long_dict_values.py b/tests/data/cases/preview_long_dict_values.py new file mode 100644 index 0000000..c1b30f2 --- /dev/null +++ b/tests/data/cases/preview_long_dict_values.py @@ -0,0 +1,303 @@ +# flags: --preview +x = { + "xx_xxxxx_xxxxxxxxxx_xxxxxxxxx_xx": ( + "xx:xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxx{xx}xxx_xxxxx_xxxxxxxxx_xxxxxxxxxxxx_xxxx" + ) +} +x = { + "xx_xxxxx_xxxxxxxxxx_xxxxxxxxx_xx": ( + "xx:xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxx{xx}xxx_xxxxx_xxxxxxxxx_xxxxxxxxxxxx_xxxx" + ), +} +x = { + "foo": bar, + "foo": bar, + "foo": ( + xx_xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxxxxx_xxxxx_xxxxxxxxx_xxxxxxxxxxxx_xxxx + ), +} +x = { + "xx_xxxxx_xxxxxxxxxx_xxxxxxxxx_xx": "xx:xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxx" +} + +my_dict = { + "something_something": + r"Lorem ipsum dolor sit amet, an sed convenire eloquentiam \t" + r"signiferumque, duo ea vocibus consetetur scriptorem. Facer \t" + r"signiferumque, duo ea vocibus consetetur scriptorem. Facer \t", +} + +# Function calls as keys +tasks = { + get_key_name( + foo, + bar, + baz, + ): src, + loop.run_in_executor(): src, + loop.run_in_executor(xx_xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxxxxx): src, + loop.run_in_executor( + xx_xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxxxxx_xxxxx_xxxxx + ): src, + loop.run_in_executor(): ( + xx_xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxxxxx_xxxxx_xxxxxxxxx_xxxxxxxxxxxx_xxxx + ), +} + +# Dictionary comprehensions +tasks = { + key_name: ( + xx_xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxxxxx_xxxxx_xxxxxxxxx_xxxxxxxxxxxx_xxxx + ) + for src in sources +} +tasks = {key_name: foobar for src in sources} +tasks = { + get_key_name( + src, + ): "foo" + for src in sources +} +tasks = { + get_key_name( + foo, + bar, + baz, + ): src + for src in sources +} +tasks = { + get_key_name(): ( + xx_xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxxxxx_xxxxx_xxxxxxxxx_xxxxxxxxxxxx_xxxx + ) + for src in sources +} +tasks = {get_key_name(): foobar for src in sources} + + +# Delimiters inside the value +def foo(): + def bar(): + x = { + common.models.DateTimeField: datetime(2020, 1, 31, tzinfo=utc) + timedelta( + days=i + ), + } + x = { + common.models.DateTimeField: ( + datetime(2020, 1, 31, tzinfo=utc) + timedelta(days=i) + ), + } + x = { + "foobar": (123 + 456), + } + x = { + "foobar": (123) + 456, + } + + +my_dict = { + "a key in my dict": a_very_long_variable * and_a_very_long_function_call() / 100000.0 +} +my_dict = { + "a key in my dict": a_very_long_variable * and_a_very_long_function_call() * and_another_long_func() / 100000.0 +} +my_dict = { + "a key in my dict": MyClass.some_attribute.first_call().second_call().third_call(some_args="some value") +} + +{ + "xxxxxx": + xxxxxxxxxxxxxxxxxxx.xxxxxxxxxxxxxx( + xxxxxxxxxxxxxx={ + "x": + xxxxxxxxxxxxxxxxxxxxxxxxxx.xxxxxxxxxxxxxxxxxxxxxxxxxxxxx( + xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=( + xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx + .xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( + xxxxxxxxxxxxx=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx + .xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( + xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx={ + "x": x.xx, + "x": x.x, + })))) + }), +} + + +class Random: + def func(): + random_service.status.active_states.inactive = ( + make_new_top_level_state_from_dict( + { + "topLevelBase": { + "secondaryBase": { + "timestamp": 1234, + "latitude": 1, + "longitude": 2, + "actionTimestamp": Timestamp( + seconds=1530584000, nanos=0 + ).ToJsonString(), + } + }, + } + ) + ) + + +# output +x = { + "xx_xxxxx_xxxxxxxxxx_xxxxxxxxx_xx": ( + "xx:xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxx{xx}xxx_xxxxx_xxxxxxxxx_xxxxxxxxxxxx_xxxx" + ) +} +x = { + "xx_xxxxx_xxxxxxxxxx_xxxxxxxxx_xx": ( + "xx:xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxx{xx}xxx_xxxxx_xxxxxxxxx_xxxxxxxxxxxx_xxxx" + ), +} +x = { + "foo": bar, + "foo": bar, + "foo": ( + xx_xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxxxxx_xxxxx_xxxxxxxxx_xxxxxxxxxxxx_xxxx + ), +} +x = { + "xx_xxxxx_xxxxxxxxxx_xxxxxxxxx_xx": "xx:xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxx" +} + +my_dict = { + "something_something": ( + r"Lorem ipsum dolor sit amet, an sed convenire eloquentiam \t" + r"signiferumque, duo ea vocibus consetetur scriptorem. Facer \t" + r"signiferumque, duo ea vocibus consetetur scriptorem. Facer \t" + ), +} + +# Function calls as keys +tasks = { + get_key_name( + foo, + bar, + baz, + ): src, + loop.run_in_executor(): src, + loop.run_in_executor(xx_xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxxxxx): src, + loop.run_in_executor( + xx_xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxxxxx_xxxxx_xxxxx + ): src, + loop.run_in_executor(): ( + xx_xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxxxxx_xxxxx_xxxxxxxxx_xxxxxxxxxxxx_xxxx + ), +} + +# Dictionary comprehensions +tasks = { + key_name: ( + xx_xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxxxxx_xxxxx_xxxxxxxxx_xxxxxxxxxxxx_xxxx + ) + for src in sources +} +tasks = {key_name: foobar for src in sources} +tasks = { + get_key_name( + src, + ): "foo" + for src in sources +} +tasks = { + get_key_name( + foo, + bar, + baz, + ): src + for src in sources +} +tasks = { + get_key_name(): ( + xx_xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxxxxx_xxxxx_xxxxxxxxx_xxxxxxxxxxxx_xxxx + ) + for src in sources +} +tasks = {get_key_name(): foobar for src in sources} + + +# Delimiters inside the value +def foo(): + def bar(): + x = { + common.models.DateTimeField: ( + datetime(2020, 1, 31, tzinfo=utc) + timedelta(days=i) + ), + } + x = { + common.models.DateTimeField: ( + datetime(2020, 1, 31, tzinfo=utc) + timedelta(days=i) + ), + } + x = { + "foobar": 123 + 456, + } + x = { + "foobar": (123) + 456, + } + + +my_dict = { + "a key in my dict": ( + a_very_long_variable * and_a_very_long_function_call() / 100000.0 + ) +} +my_dict = { + "a key in my dict": ( + a_very_long_variable + * and_a_very_long_function_call() + * and_another_long_func() + / 100000.0 + ) +} +my_dict = { + "a key in my dict": ( + MyClass.some_attribute.first_call() + .second_call() + .third_call(some_args="some value") + ) +} + +{ + "xxxxxx": xxxxxxxxxxxxxxxxxxx.xxxxxxxxxxxxxx( + xxxxxxxxxxxxxx={ + "x": xxxxxxxxxxxxxxxxxxxxxxxxxx.xxxxxxxxxxxxxxxxxxxxxxxxxxxxx( + xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=( + xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( + xxxxxxxxxxxxx=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( + xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx={ + "x": x.xx, + "x": x.x, + } + ) + ) + ) + ) + } + ), +} + + +class Random: + def func(): + random_service.status.active_states.inactive = make_new_top_level_state_from_dict( + { + "topLevelBase": { + "secondaryBase": { + "timestamp": 1234, + "latitude": 1, + "longitude": 2, + "actionTimestamp": ( + Timestamp(seconds=1530584000, nanos=0).ToJsonString() + ), + } + }, + } + ) diff --git a/tests/data/cases/preview_long_strings.py b/tests/data/cases/preview_long_strings.py new file mode 100644 index 0000000..177f866 --- /dev/null +++ b/tests/data/cases/preview_long_strings.py @@ -0,0 +1,964 @@ +# flags: --unstable +x = "This is a really long string that can't possibly be expected to fit all together on one line. In fact it may even take up three or more lines... like four or five... but probably just three." + +x += "This is a really long string that can't possibly be expected to fit all together on one line. In fact it may even take up three or more lines... like four or five... but probably just three." + +y = ( + 'Short string' +) + +print('This is a really long string inside of a print statement with extra arguments attached at the end of it.', x, y, z) + +print("This is a really long string inside of a print statement with no extra arguments attached at the end of it.") + +D1 = {"The First": "This is a really long string that can't possibly be expected to fit all together on one line. Also it is inside a dictionary, so formatting is more difficult.", "The Second": "This is another really really (not really) long string that also can't be expected to fit on one line and is, like the other string, inside a dictionary."} + +D2 = {1.0: "This is a really long string that can't possibly be expected to fit all together on one line. Also it is inside a dictionary, so formatting is more difficult.", 2.0: "This is another really really (not really) long string that also can't be expected to fit on one line and is, like the other string, inside a dictionary."} + +D3 = {x: "This is a really long string that can't possibly be expected to fit all together on one line. Also it is inside a dictionary, so formatting is more difficult.", y: "This is another really really (not really) long string that also can't be expected to fit on one line and is, like the other string, inside a dictionary."} + +D4 = {"A long and ridiculous {}".format(string_key): "This is a really really really long string that has to go i,side of a dictionary. It is soooo bad.", some_func("calling", "some", "stuff"): "This is a really really really long string that has to go inside of a dictionary. It is {soooo} bad (#{x}).".format(sooo="soooo", x=2), "A %s %s" % ("formatted", "string"): "This is a really really really long string that has to go inside of a dictionary. It is %s bad (#%d)." % ("soooo", 2)} + +D5 = { # Test for https://github.com/psf/black/issues/3261 + ("This is a really long string that can't be expected to fit in one line and is used as a nested dict's key"): {"inner": "value"}, +} + +D6 = { # Test for https://github.com/psf/black/issues/3261 + ("This is a really long string that can't be expected to fit in one line and is used as a dict's key"): ["value1", "value2"], +} + +L1 = ["The is a short string", "This is a really long string that can't possibly be expected to fit all together on one line. Also it is inside a list literal, so it's expected to be wrapped in parens when splitting to avoid implicit str concatenation.", short_call("arg", {"key": "value"}), "This is another really really (not really) long string that also can't be expected to fit on one line and is, like the other string, inside a list literal.", ("parens should be stripped for short string in list")] + +L2 = ["This is a really long string that can't be expected to fit in one line and is the only child of a list literal."] + +S1 = {"The is a short string", "This is a really long string that can't possibly be expected to fit all together on one line. Also it is inside a set literal, so it's expected to be wrapped in parens when splitting to avoid implicit str concatenation.", short_call("arg", {"key": "value"}), "This is another really really (not really) long string that also can't be expected to fit on one line and is, like the other string, inside a set literal.", ("parens should be stripped for short string in set")} + +S2 = {"This is a really long string that can't be expected to fit in one line and is the only child of a set literal."} + +T1 = ("The is a short string", "This is a really long string that can't possibly be expected to fit all together on one line. Also it is inside a tuple literal, so it's expected to be wrapped in parens when splitting to avoid implicit str concatenation.", short_call("arg", {"key": "value"}), "This is another really really (not really) long string that also can't be expected to fit on one line and is, like the other string, inside a tuple literal.", ("parens should be stripped for short string in list")) + +T2 = ("This is a really long string that can't be expected to fit in one line and is the only child of a tuple literal.",) + +# Test case for https://github.com/psf/black/issues/4912 - unassigned long string with trailing comma +"A long string literal that is not assigned to a variable, exceeds line length when string-processing is enabled, and has a trailing comma (to make it a one-item tuple)", + +func_with_keywords(my_arg, my_kwarg="Long keyword strings also need to be wrapped, but they will probably need to be handled a little bit differently.") + +bad_split1 = ( + 'But what should happen when code has already been formatted but in the wrong way? Like' + " with a space at the end instead of the beginning. Or what about when it is split too soon?" +) + +bad_split2 = "But what should happen when code has already " \ + "been formatted but in the wrong way? Like " \ + "with a space at the end instead of the " \ + "beginning. Or what about when it is split too " \ + "soon? In the case of a split that is too " \ + "short, black will try to honer the custom " \ + "split." + +bad_split3 = ( + "What if we have inline comments on " # First Comment + "each line of a bad split? In that " # Second Comment + "case, we should just leave it alone." # Third Comment +) + +bad_split_func1( + "But what should happen when code has already " + "been formatted but in the wrong way? Like " + "with a space at the end instead of the " + "beginning. Or what about when it is split too " + "soon? In the case of a split that is too " + "short, black will try to honer the custom " + "split.", + xxx, yyy, zzz +) + +bad_split_func2( + xxx, yyy, zzz, + long_string_kwarg="But what should happen when code has already been formatted but in the wrong way? Like " + "with a space at the end instead of the beginning. Or what about when it is split too " + "soon?", +) + +bad_split_func3( + ( + "But what should happen when code has already " + r"been formatted but in the wrong way? Like " + "with a space at the end instead of the " + r"beginning. Or what about when it is split too " + r"soon? In the case of a split that is too " + "short, black will try to honer the custom " + "split." + ), + xxx, + yyy, + zzz, +) + +inline_comments_func1( + "if there are inline " + "comments in the middle " + # Here is the standard alone comment. + "of the implicitly concatenated " + "string, we should handle " + "them correctly", + xxx, +) + +inline_comments_func2( + "what if the string is very very very very very very very very very very long and this part does " + "not fit into a single line? " + # Here is the standard alone comment. + "then the string should still be properly handled by merging and splitting " + "it into parts that fit in line length.", + xxx, +) + +raw_string = r"This is a long raw string. When re-formatting this string, black needs to make sure it prepends the 'r' onto the new string." + +fmt_string1 = "We also need to be sure to preserve any and all {} which may or may not be attached to the string in question.".format("method calls") + +fmt_string2 = "But what about when the string is {} but {}".format("short", "the method call is really really really really really really really really long?") + +old_fmt_string1 = "While we are on the topic of %s, we should also note that old-style formatting must also be preserved, since some %s still uses it." % ("formatting", "code") + +old_fmt_string2 = "This is a %s %s %s %s" % ("really really really really really", "old", "way to format strings!", "Use f-strings instead!") + +old_fmt_string3 = "Whereas only the strings after the percent sign were long in the last example, this example uses a long initial string as well. This is another %s %s %s %s" % ("really really really really really", "old", "way to format strings!", "Use f-strings instead!") + +fstring = f"f-strings definitely make things more {difficult} than they need to be for {{black}}. But boy they sure are handy. The problem is that some lines will need to have the 'f' whereas others do not. This {line}, for example, needs one." + +fstring_with_no_fexprs = f"Some regular string that needs to get split certainly but is NOT an fstring by any means whatsoever." + +comment_string = "Long lines with inline comments should have their comments appended to the reformatted string's enclosing right parentheses." # This comment gets thrown to the top. + +arg_comment_string = print("Long lines with inline comments which are apart of (and not the only member of) an argument list should have their comments appended to the reformatted string's enclosing left parentheses.", # This comment gets thrown to the top. + "Arg #2", "Arg #3", "Arg #4", "Arg #5") + +pragma_comment_string1 = "Lines which end with an inline pragma comment of the form `# : <...>` should be left alone." # noqa: E501 + +pragma_comment_string2 = "Lines which end with an inline pragma comment of the form `# : <...>` should be left alone." # noqa + +"""This is a really really really long triple quote string and it should not be touched.""" + +triple_quote_string = """This is a really really really long triple quote string assignment and it should not be touched.""" + +assert some_type_of_boolean_expression, "Followed by a really really really long string that is used to provide context to the AssertionError exception." + +assert some_type_of_boolean_expression, "Followed by a really really really long string that is used to provide context to the AssertionError exception, which uses dynamic string {}.".format("formatting") + +assert some_type_of_boolean_expression, "Followed by a really really really long string that is used to provide context to the AssertionError exception, which uses dynamic string %s." % "formatting" + +assert some_type_of_boolean_expression, "Followed by a really really really long string that is used to provide context to the AssertionError exception, which uses dynamic %s %s." % ("string", "formatting") + +some_function_call("With a reallly generic name and with a really really long string that is, at some point down the line, " + added + " to a variable and then added to another string.") + +some_function_call("With a reallly generic name and with a really really long string that is, at some point down the line, " + added + " to a variable and then added to another string. But then what happens when the final string is also supppppperrrrr long?! Well then that second (realllllllly long) string should be split too.", "and a second argument", and_a_third) + +return "A really really really really really really really really really really really really really long {} {}".format("return", "value") + +func_with_bad_comma( + "This is a really long string argument to a function that has a trailing comma which should NOT be there.", +) + +func_with_bad_comma( + "This is a really long string argument to a function that has a trailing comma which should NOT be there.", # comment after comma +) + +func_with_bad_comma( + ( + "This is a really long string argument to a function that has a trailing comma" + " which should NOT be there." + ), +) + +func_with_bad_comma( + ( + "This is a really long string argument to a function that has a trailing comma" + " which should NOT be there." + ), # comment after comma +) + +func_with_bad_parens_that_wont_fit_in_one_line( + ("short string that should have parens stripped"), + x, + y, + z +) + +func_with_bad_parens_that_wont_fit_in_one_line( + x, + y, + ("short string that should have parens stripped"), + z +) + +func_with_bad_parens( + ("short string that should have parens stripped"), + x, + y, + z, +) + +func_with_bad_parens( + x, + y, + ("short string that should have parens stripped"), + z, +) + +annotated_variable: Final = "This is a large " + STRING + " that has been " + CONCATENATED + "using the '+' operator." +annotated_variable: Final = "This is a large string that has a type annotation attached to it. A type annotation should NOT stop a long string from being wrapped." +annotated_variable: Literal["fakse_literal"] = "This is a large string that has a type annotation attached to it. A type annotation should NOT stop a long string from being wrapped." + +backslashes = "This is a really long string with \"embedded\" double quotes and 'single' quotes that also handles checking for an even number of backslashes \\" +backslashes = "This is a really long string with \"embedded\" double quotes and 'single' quotes that also handles checking for an even number of backslashes \\\\" +backslashes = "This is a really 'long' string with \"embedded double quotes\" and 'single' quotes that also handles checking for an odd number of backslashes \\\", like this...\\\\\\" + +short_string = ( + "Hi" + " there." +) + +func_call( + short_string=( + "Hi" + " there." + ) +) + +raw_strings = r"Don't" " get" r" merged" " unless they are all raw." + +def foo(): + yield "This is a really long string that can't possibly be expected to fit all together on one line. In fact it may even take up three or more lines... like four or five... but probably just three." + +x = f"This is a {{really}} long string that needs to be split without a doubt (i.e. most definitely). In short, this {string} that can't possibly be {{expected}} to fit all together on one line. In {fact} it may even take up three or more lines... like four or five... but probably just four." + +long_unmergable_string_with_pragma = ( + "This is a really long string that can't be merged because it has a likely pragma at the end" # type: ignore + " of it." +) + +long_unmergable_string_with_pragma = ( + "This is a really long string that can't be merged because it has a likely pragma at the end" # noqa + " of it." +) + +long_unmergable_string_with_pragma = ( + "This is a really long string that can't be merged because it has a likely pragma at the end" # pylint: disable=some-pylint-check + " of it." +) + +string_with_nameescape = ( + "........................................................................ \N{LAO KO LA}" +) + +string_with_nameescape = ( + "........................................................................... \N{LAO KO LA}" +) + +string_with_nameescape = ( + "............................................................................ \N{LAO KO LA}" +) + +string_with_nameescape_and_escaped_backslash = ( + "...................................................................... \\\N{LAO KO LA}" +) + +string_with_nameescape_and_escaped_backslash = ( + "......................................................................... \\\N{LAO KO LA}" +) + +string_with_nameescape_and_escaped_backslash = ( + ".......................................................................... \\\N{LAO KO LA}" +) + +string_with_escaped_nameescape = ( + "........................................................................ \\N{LAO KO LA}" +) + +string_with_escaped_nameescape = ( + "........................................................................... \\N{LAO KO LA}" +) + +msg = lambda x: f"this is a very very very very long lambda value {x} that doesn't fit on a single line" + +dict_with_lambda_values = { + "join": lambda j: ( + f"{j.__class__.__name__}({some_function_call(j.left)}, " + f"{some_function_call(j.right)})" + ), +} + +# Complex string concatenations with a method call in the middle. +code = ( + (" return [\n") + + ( + ", \n".join( + " (%r, self.%s, visitor.%s)" + % (attrname, attrname, visit_name) + for attrname, visit_name in names + ) + ) + + ("\n ]\n") +) + + +# Test case of an outer string' parens enclose an inner string's parens. +call(body=("%s %s" % ((",".join(items)), suffix))) + +log.info(f'Skipping: {desc["db_id"]=} {desc["ms_name"]} {money=} {dte=} {pos_share=} {desc["status"]=} {desc["exposure_max"]=}') + +log.info(f"Skipping: {desc['db_id']=} {desc['ms_name']} {money=} {dte=} {pos_share=} {desc['status']=} {desc['exposure_max']=}") + +log.info(f'Skipping: {desc["db_id"]} {foo("bar",x=123)} {"foo" != "bar"} {(x := "abc=")} {pos_share=} {desc["status"]} {desc["exposure_max"]}') + +log.info(f'Skipping: {desc["db_id"]} {desc["ms_name"]} {money=} {(x := "abc=")=} {pos_share=} {desc["status"]} {desc["exposure_max"]}') + +log.info(f'Skipping: {desc["db_id"]} {foo("bar",x=123)=} {money=} {dte=} {pos_share=} {desc["status"]} {desc["exposure_max"]}') + +log.info(f'Skipping: {foo("asdf")=} {desc["ms_name"]} {money=} {dte=} {pos_share=} {desc["status"]} {desc["exposure_max"]}') + +log.info(f'Skipping: {"a" == "b" == "c" == "d"} {desc["ms_name"]} {money=} {dte=} {pos_share=} {desc["status"]} {desc["exposure_max"]}') + +log.info(f'Skipping: {"a" == "b" == "c" == "d"=} {desc["ms_name"]} {money=} {dte=} {pos_share=} {desc["status"]} {desc["exposure_max"]}') + +log.info(f'Skipping: { longer_longer_longer_longer_longer_longer_name [ "db_id" ] [ "another_key" ] = : .3f }') + +log.info(f'''Skipping: {"a" == 'b'} {desc["ms_name"]} {money=} {dte=} {pos_share=} {desc["status"]} {desc["exposure_max"]}''') + +log.info(f'''Skipping: {'a' == "b"=} {desc["ms_name"]} {money=} {dte=} {pos_share=} {desc["status"]} {desc["exposure_max"]}''') + +log.info(f"""Skipping: {'a' == 'b'} {desc['ms_name']} {money=} {dte=} {pos_share=} {desc['status']} {desc['exposure_max']}""") + +x = { + "xx_xxxxx_xxxxxxxxxx_xxxxxxxxx_xx": ( + "xx:xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxx{xx}xxx_xxxxx_xxxxxxxxx_xxxxxxxxxxxx_xxxx" + ) +} +x = { + "xx_xxxxx_xxxxxxxxxx_xxxxxxxxx_xx": "xx:xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxx{xx}xxx_xxxxx_xxxxxxxxx_xxxxxxxxxxxx_xxxx", +} +x = { + "xx_xxxxx_xxxxxxxxxx_xxxxxxxxx_xx": ( + "xx:xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxx" + ) +} + +# output + + +x = ( + "This is a really long string that can't possibly be expected to fit all together" + " on one line. In fact it may even take up three or more lines... like four or" + " five... but probably just three." +) + +x += ( + "This is a really long string that can't possibly be expected to fit all together" + " on one line. In fact it may even take up three or more lines... like four or" + " five... but probably just three." +) + +y = "Short string" + +print( + "This is a really long string inside of a print statement with extra arguments" + " attached at the end of it.", + x, + y, + z, +) + +print( + "This is a really long string inside of a print statement with no extra arguments" + " attached at the end of it." +) + +D1 = { + "The First": ( + "This is a really long string that can't possibly be expected to fit all" + " together on one line. Also it is inside a dictionary, so formatting is more" + " difficult." + ), + "The Second": ( + "This is another really really (not really) long string that also can't be" + " expected to fit on one line and is, like the other string, inside a" + " dictionary." + ), +} + +D2 = { + 1.0: ( + "This is a really long string that can't possibly be expected to fit all" + " together on one line. Also it is inside a dictionary, so formatting is more" + " difficult." + ), + 2.0: ( + "This is another really really (not really) long string that also can't be" + " expected to fit on one line and is, like the other string, inside a" + " dictionary." + ), +} + +D3 = { + x: ( + "This is a really long string that can't possibly be expected to fit all" + " together on one line. Also it is inside a dictionary, so formatting is more" + " difficult." + ), + y: ( + "This is another really really (not really) long string that also can't be" + " expected to fit on one line and is, like the other string, inside a" + " dictionary." + ), +} + +D4 = { + "A long and ridiculous {}".format(string_key): ( + "This is a really really really long string that has to go i,side of a" + " dictionary. It is soooo bad." + ), + some_func("calling", "some", "stuff"): ( + "This is a really really really long string that has to go inside of a" + " dictionary. It is {soooo} bad (#{x}).".format(sooo="soooo", x=2) + ), + "A %s %s" + % ("formatted", "string"): ( + "This is a really really really long string that has to go inside of a" + " dictionary. It is %s bad (#%d)." % ("soooo", 2) + ), +} + +D5 = { # Test for https://github.com/psf/black/issues/3261 + "This is a really long string that can't be expected to fit in one line and is used as a nested dict's key": { + "inner": "value" + }, +} + +D6 = { # Test for https://github.com/psf/black/issues/3261 + "This is a really long string that can't be expected to fit in one line and is used as a dict's key": [ + "value1", + "value2", + ], +} + +L1 = [ + "The is a short string", + ( + "This is a really long string that can't possibly be expected to fit all" + " together on one line. Also it is inside a list literal, so it's expected to" + " be wrapped in parens when splitting to avoid implicit str concatenation." + ), + short_call("arg", {"key": "value"}), + ( + "This is another really really (not really) long string that also can't be" + " expected to fit on one line and is, like the other string, inside a list" + " literal." + ), + "parens should be stripped for short string in list", +] + +L2 = [ + "This is a really long string that can't be expected to fit in one line and is the" + " only child of a list literal." +] + +S1 = { + "The is a short string", + ( + "This is a really long string that can't possibly be expected to fit all" + " together on one line. Also it is inside a set literal, so it's expected to be" + " wrapped in parens when splitting to avoid implicit str concatenation." + ), + short_call("arg", {"key": "value"}), + ( + "This is another really really (not really) long string that also can't be" + " expected to fit on one line and is, like the other string, inside a set" + " literal." + ), + "parens should be stripped for short string in set", +} + +S2 = { + "This is a really long string that can't be expected to fit in one line and is the" + " only child of a set literal." +} + +T1 = ( + "The is a short string", + ( + "This is a really long string that can't possibly be expected to fit all" + " together on one line. Also it is inside a tuple literal, so it's expected to" + " be wrapped in parens when splitting to avoid implicit str concatenation." + ), + short_call("arg", {"key": "value"}), + ( + "This is another really really (not really) long string that also can't be" + " expected to fit on one line and is, like the other string, inside a tuple" + " literal." + ), + "parens should be stripped for short string in list", +) + +T2 = ( + ( + "This is a really long string that can't be expected to fit in one line and is" + " the only child of a tuple literal." + ), +) + +# Test case for https://github.com/psf/black/issues/4912 - unassigned long string with trailing comma +( + "A long string literal that is not assigned to a variable, exceeds line length when" + " string-processing is enabled, and has a trailing comma (to make it a one-item" + " tuple)" +), + +func_with_keywords( + my_arg, + my_kwarg=( + "Long keyword strings also need to be wrapped, but they will probably need to" + " be handled a little bit differently." + ), +) + +bad_split1 = ( + "But what should happen when code has already been formatted but in the wrong way?" + " Like with a space at the end instead of the beginning. Or what about when it is" + " split too soon?" +) + +bad_split2 = ( + "But what should happen when code has already " + "been formatted but in the wrong way? Like " + "with a space at the end instead of the " + "beginning. Or what about when it is split too " + "soon? In the case of a split that is too " + "short, black will try to honer the custom " + "split." +) + +bad_split3 = ( + "What if we have inline comments on " # First Comment + "each line of a bad split? In that " # Second Comment + "case, we should just leave it alone." # Third Comment +) + +bad_split_func1( + "But what should happen when code has already " + "been formatted but in the wrong way? Like " + "with a space at the end instead of the " + "beginning. Or what about when it is split too " + "soon? In the case of a split that is too " + "short, black will try to honer the custom " + "split.", + xxx, + yyy, + zzz, +) + +bad_split_func2( + xxx, + yyy, + zzz, + long_string_kwarg=( + "But what should happen when code has already been formatted but in the wrong" + " way? Like with a space at the end instead of the beginning. Or what about" + " when it is split too soon?" + ), +) + +bad_split_func3( + ( + "But what should happen when code has already " + r"been formatted but in the wrong way? Like " + "with a space at the end instead of the " + r"beginning. Or what about when it is split too " + r"soon? In the case of a split that is too " + "short, black will try to honer the custom " + "split." + ), + xxx, + yyy, + zzz, +) + +inline_comments_func1( + "if there are inline comments in the middle " + # Here is the standard alone comment. + "of the implicitly concatenated string, we should handle them correctly", + xxx, +) + +inline_comments_func2( + "what if the string is very very very very very very very very very very long and" + " this part does not fit into a single line? " + # Here is the standard alone comment. + "then the string should still be properly handled by merging and splitting " + "it into parts that fit in line length.", + xxx, +) + +raw_string = ( + r"This is a long raw string. When re-formatting this string, black needs to make" + r" sure it prepends the 'r' onto the new string." +) + +fmt_string1 = ( + "We also need to be sure to preserve any and all {} which may or may not be" + " attached to the string in question.".format("method calls") +) + +fmt_string2 = "But what about when the string is {} but {}".format( + "short", + "the method call is really really really really really really really really long?", +) + +old_fmt_string1 = ( + "While we are on the topic of %s, we should also note that old-style formatting" + " must also be preserved, since some %s still uses it." % ("formatting", "code") +) + +old_fmt_string2 = "This is a %s %s %s %s" % ( + "really really really really really", + "old", + "way to format strings!", + "Use f-strings instead!", +) + +old_fmt_string3 = ( + "Whereas only the strings after the percent sign were long in the last example," + " this example uses a long initial string as well. This is another %s %s %s %s" + % ( + "really really really really really", + "old", + "way to format strings!", + "Use f-strings instead!", + ) +) + +fstring = ( + f"f-strings definitely make things more {difficult} than they need to be for" + " {black}. But boy they sure are handy. The problem is that some lines will need" + f" to have the 'f' whereas others do not. This {line}, for example, needs one." +) + +fstring_with_no_fexprs = ( + f"Some regular string that needs to get split certainly but is NOT an fstring by" + f" any means whatsoever." +) + +comment_string = ( # This comment gets thrown to the top. + "Long lines with inline comments should have their comments appended to the" + " reformatted string's enclosing right parentheses." +) + +arg_comment_string = print( + "Long lines with inline comments which are apart of (and not the only member of) an" + " argument list should have their comments appended to the reformatted string's" + " enclosing left parentheses.", # This comment gets thrown to the top. + "Arg #2", + "Arg #3", + "Arg #4", + "Arg #5", +) + +pragma_comment_string1 = "Lines which end with an inline pragma comment of the form `# : <...>` should be left alone." # noqa: E501 + +pragma_comment_string2 = "Lines which end with an inline pragma comment of the form `# : <...>` should be left alone." # noqa + +"""This is a really really really long triple quote string and it should not be touched.""" + +triple_quote_string = """This is a really really really long triple quote string assignment and it should not be touched.""" + +assert some_type_of_boolean_expression, ( + "Followed by a really really really long string that is used to provide context to" + " the AssertionError exception." +) + +assert some_type_of_boolean_expression, ( + "Followed by a really really really long string that is used to provide context to" + " the AssertionError exception, which uses dynamic string {}.".format("formatting") +) + +assert some_type_of_boolean_expression, ( + "Followed by a really really really long string that is used to provide context to" + " the AssertionError exception, which uses dynamic string %s." % "formatting" +) + +assert some_type_of_boolean_expression, ( + "Followed by a really really really long string that is used to provide context to" + " the AssertionError exception, which uses dynamic %s %s." + % ("string", "formatting") +) + +some_function_call( + "With a reallly generic name and with a really really long string that is, at some" + " point down the line, " + + added + + " to a variable and then added to another string." +) + +some_function_call( + "With a reallly generic name and with a really really long string that is, at some" + " point down the line, " + + added + + " to a variable and then added to another string. But then what happens when the" + " final string is also supppppperrrrr long?! Well then that second (realllllllly" + " long) string should be split too.", + "and a second argument", + and_a_third, +) + +return ( + "A really really really really really really really really really really really" + " really really long {} {}".format("return", "value") +) + +func_with_bad_comma( + "This is a really long string argument to a function that has a trailing comma" + " which should NOT be there.", +) + +func_with_bad_comma( + "This is a really long string argument to a function that has a trailing comma" + " which should NOT be there.", # comment after comma +) + +func_with_bad_comma( + "This is a really long string argument to a function that has a trailing comma" + " which should NOT be there.", +) + +func_with_bad_comma( + "This is a really long string argument to a function that has a trailing comma" + " which should NOT be there.", # comment after comma +) + +func_with_bad_parens_that_wont_fit_in_one_line( + "short string that should have parens stripped", x, y, z +) + +func_with_bad_parens_that_wont_fit_in_one_line( + x, y, "short string that should have parens stripped", z +) + +func_with_bad_parens( + "short string that should have parens stripped", + x, + y, + z, +) + +func_with_bad_parens( + x, + y, + "short string that should have parens stripped", + z, +) + +annotated_variable: Final = ( + "This is a large " + + STRING + + " that has been " + + CONCATENATED + + "using the '+' operator." +) +annotated_variable: Final = ( + "This is a large string that has a type annotation attached to it. A type" + " annotation should NOT stop a long string from being wrapped." +) +annotated_variable: Literal["fakse_literal"] = ( + "This is a large string that has a type annotation attached to it. A type" + " annotation should NOT stop a long string from being wrapped." +) + +backslashes = ( + "This is a really long string with \"embedded\" double quotes and 'single' quotes" + " that also handles checking for an even number of backslashes \\" +) +backslashes = ( + "This is a really long string with \"embedded\" double quotes and 'single' quotes" + " that also handles checking for an even number of backslashes \\\\" +) +backslashes = ( + "This is a really 'long' string with \"embedded double quotes\" and 'single' quotes" + ' that also handles checking for an odd number of backslashes \\", like' + " this...\\\\\\" +) + +short_string = "Hi there." + +func_call(short_string="Hi there.") + +raw_strings = r"Don't" " get" r" merged" " unless they are all raw." + + +def foo(): + yield ( + "This is a really long string that can't possibly be expected to fit all" + " together on one line. In fact it may even take up three or more lines... like" + " four or five... but probably just three." + ) + + +x = ( + "This is a {really} long string that needs to be split without a doubt (i.e." + f" most definitely). In short, this {string} that can't possibly be {{expected}} to" + f" fit all together on one line. In {fact} it may even take up three or more" + " lines... like four or five... but probably just four." +) + +long_unmergable_string_with_pragma = ( + "This is a really long string that can't be merged because it has a likely pragma at the end" # type: ignore + " of it." +) + +long_unmergable_string_with_pragma = ( + "This is a really long string that can't be merged because it has a likely pragma at the end" # noqa + " of it." +) + +long_unmergable_string_with_pragma = ( + "This is a really long string that can't be merged because it has a likely pragma at the end" # pylint: disable=some-pylint-check + " of it." +) + +string_with_nameescape = ( + "........................................................................" + " \N{LAO KO LA}" +) + +string_with_nameescape = ( + "..........................................................................." + " \N{LAO KO LA}" +) + +string_with_nameescape = ( + "............................................................................" + " \N{LAO KO LA}" +) + +string_with_nameescape_and_escaped_backslash = ( + "......................................................................" + " \\\N{LAO KO LA}" +) + +string_with_nameescape_and_escaped_backslash = ( + "........................................................................." + " \\\N{LAO KO LA}" +) + +string_with_nameescape_and_escaped_backslash = ( + ".........................................................................." + " \\\N{LAO KO LA}" +) + +string_with_escaped_nameescape = ( + "........................................................................ \\N{LAO" + " KO LA}" +) + +string_with_escaped_nameescape = ( + "..........................................................................." + " \\N{LAO KO LA}" +) + +msg = lambda x: ( + f"this is a very very very very long lambda value {x} that doesn't fit on a" + " single line" +) + +dict_with_lambda_values = { + "join": lambda j: ( + f"{j.__class__.__name__}({some_function_call(j.left)}, " + f"{some_function_call(j.right)})" + ), +} + +# Complex string concatenations with a method call in the middle. +code = ( + " return [\n" + + ", \n".join( + " (%r, self.%s, visitor.%s)" % (attrname, attrname, visit_name) + for attrname, visit_name in names + ) + + "\n ]\n" +) + + +# Test case of an outer string' parens enclose an inner string's parens. +call(body="%s %s" % (",".join(items), suffix)) + +log.info( + f'Skipping: {desc["db_id"]=} {desc["ms_name"]} {money=} {dte=} {pos_share=}' + f' {desc["status"]=} {desc["exposure_max"]=}' +) + +log.info( + f"Skipping: {desc['db_id']=} {desc['ms_name']} {money=} {dte=} {pos_share=}" + f" {desc['status']=} {desc['exposure_max']=}" +) + +log.info( + f'Skipping: {desc["db_id"]} {foo("bar",x=123)} {"foo" != "bar"} {(x := "abc=")}' + f' {pos_share=} {desc["status"]} {desc["exposure_max"]}' +) + +log.info( + f'Skipping: {desc["db_id"]} {desc["ms_name"]} {money=} {(x := "abc=")=}' + f' {pos_share=} {desc["status"]} {desc["exposure_max"]}' +) + +log.info( + f'Skipping: {desc["db_id"]} {foo("bar",x=123)=} {money=} {dte=} {pos_share=}' + f' {desc["status"]} {desc["exposure_max"]}' +) + +log.info( + f'Skipping: {foo("asdf")=} {desc["ms_name"]} {money=} {dte=} {pos_share=}' + f' {desc["status"]} {desc["exposure_max"]}' +) + +log.info( + f'Skipping: {"a" == "b" == "c" == "d"} {desc["ms_name"]} {money=} {dte=}' + f' {pos_share=} {desc["status"]} {desc["exposure_max"]}' +) + +log.info( + f'Skipping: {"a" == "b" == "c" == "d"=} {desc["ms_name"]} {money=} {dte=}' + f' {pos_share=} {desc["status"]} {desc["exposure_max"]}' +) + +log.info( + "Skipping:" + f' { longer_longer_longer_longer_longer_longer_name [ "db_id" ] [ "another_key" ] = : .3f }' +) + +log.info( + f"""Skipping: {"a" == 'b'} {desc["ms_name"]} {money=} {dte=} {pos_share=} {desc["status"]} {desc["exposure_max"]}""" +) + +log.info( + f"""Skipping: {'a' == "b"=} {desc["ms_name"]} {money=} {dte=} {pos_share=} {desc["status"]} {desc["exposure_max"]}""" +) + +log.info( + f"""Skipping: {'a' == 'b'} {desc['ms_name']} {money=} {dte=} {pos_share=} {desc['status']} {desc['exposure_max']}""" +) + +x = { + "xx_xxxxx_xxxxxxxxxx_xxxxxxxxx_xx": ( + "xx:xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxx{xx}xxx_xxxxx_xxxxxxxxx_xxxxxxxxxxxx_xxxx" + ) +} +x = { + "xx_xxxxx_xxxxxxxxxx_xxxxxxxxx_xx": ( + "xx:xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxxx{xx}xxx_xxxxx_xxxxxxxxx_xxxxxxxxxxxx_xxxx" + ), +} +x = { + "xx_xxxxx_xxxxxxxxxx_xxxxxxxxx_xx": "xx:xxxxxxxxxxxxxxxxx_xxxxx_xxxxxxx_xxxxxxxxxx" +} diff --git a/tests/data/cases/preview_long_strings__east_asian_width.py b/tests/data/cases/preview_long_strings__east_asian_width.py new file mode 100644 index 0000000..01165f9 --- /dev/null +++ b/tests/data/cases/preview_long_strings__east_asian_width.py @@ -0,0 +1,57 @@ +# flags: --unstable +# The following strings do not have not-so-many chars, but are long enough +# when these are rendered in a monospace font (if the renderer respects +# Unicode East Asian Width properties). +hangul = '코드포인트 수는 적으나 실제 터미널이나 에디터에서 렌더링될 땐 너무 길어서 줄바꿈이 필요한 문자열' +hanzi = '中文測試：代碼點數量少，但在真正的終端模擬器或編輯器中呈現時太長，因此需要換行的字符串。' +japanese = 'コードポイントの数は少ないが、実際の端末エミュレータやエディタでレンダリングされる時は長すぎる為、改行が要る文字列' +khmer = 'សម្រស់ទាវ២០២២ មិនធម្មតា ឥឡូវកំពុងរកតួ នេនទុំ និងពេជ្រ ប្រញាប់ឡើងទាន់គេមានបញ្ហាត្រូវថតឡើងវិញ ប្រញាប់ឡើងទាន់គេមានបញ្ហាត្រូវថតឡើងវិញ' +# Should stay the same +khmer_same = [ + "text, expected_language", + [ + ( + ( + "សម្រស់ទាវ២០២២ មិនធម្មតា ឥឡូវកំពុងរកតួ នេនទុំ និងពេជ្រ" + " ប្រញាប់ឡើងទាន់គេមានបញ្ហាត្រូវថតឡើងវិញ " + ), + "km", + ), # Khmer + ], +] + +# output + +# The following strings do not have not-so-many chars, but are long enough +# when these are rendered in a monospace font (if the renderer respects +# Unicode East Asian Width properties). +hangul = ( + "코드포인트 수는 적으나 실제 터미널이나 에디터에서 렌더링될 땐 너무 길어서 줄바꿈이" + " 필요한 문자열" +) +hanzi = ( + "中文測試：代碼點數量少，但在真正的終端模擬器或編輯器中呈現時太長，" + "因此需要換行的字符串。" +) +japanese = ( + "コードポイントの数は少ないが、" + "実際の端末エミュレータやエディタでレンダリングされる時は長すぎる為、" + "改行が要る文字列" +) +khmer = ( + "សម្រស់ទាវ២០២២ មិនធម្មតា ឥឡូវកំពុងរកតួ នេនទុំ និងពេជ្រ" + " ប្រញាប់ឡើងទាន់គេមានបញ្ហាត្រូវថតឡើងវិញ ប្រញាប់ឡើងទាន់គេមានបញ្ហាត្រូវថតឡើងវិញ" +) +# Should stay the same +khmer_same = [ + "text, expected_language", + [ + ( + ( + "សម្រស់ទាវ២០២២ មិនធម្មតា ឥឡូវកំពុងរកតួ នេនទុំ និងពេជ្រ" + " ប្រញាប់ឡើងទាន់គេមានបញ្ហាត្រូវថតឡើងវិញ " + ), + "km", + ), # Khmer + ], +] diff --git a/tests/data/cases/preview_long_strings__edge_case.py b/tests/data/cases/preview_long_strings__edge_case.py new file mode 100644 index 0000000..28497e7 --- /dev/null +++ b/tests/data/cases/preview_long_strings__edge_case.py @@ -0,0 +1,141 @@ +# flags: --unstable +some_variable = "This string is long but not so long that it needs to be split just yet" +some_variable = 'This string is long but not so long that it needs to be split just yet' +some_variable = "This string is long, just long enough that it needs to be split, u get?" +some_variable = 'This string is long, just long enough that it needs to be split, u get?' +some_variable = "This string is long, just long enough that it needs to be split, u get? So we stay" +some_variable = 'This string is long, just long enough that it needs to be split, u get? So we stay' +some_variable = "This string is long, just long enough that it needs to be split, u get? So we split" +some_variable = 'This string is long, just long enough that it needs to be split, u get? So we split' +some_variable = "This string is long but not so long that it needs hahahah toooooo be so greatttt {} that I just can't think of any more good words to say about it at alll".format("ha") +some_variable = "This string is long but not so long that it needs hahahah toooooo be so greatttt {} that I just can't think of any more good words to say about it at allll".format("ha") +some_variable = "This string is long but not so long that it needs hahahah toooooo be so greatttt {} that I just can't think of any more good words to say about it at alllllllllll".format("ha") +some_variable = "This string is long but not so long that it needs hahahah toooooo be so greatttt {} that I just can't think of any more good words to say about it at allllllllllll".format("ha") +some_variable = "This is a long string that will end with a method that is not calleddd".format +addition_inside_tuple = ( + some_string_inside_a_variable + + "Some string that is just long enough to cause a split to take place.............", + xyz, + "Some really long string that needs to get split eventually but I'm running out of things to say" + some_string_inside_a_variable +) +addition_inside_tuple = ( + some_string_inside_a_variable + + "Some string that is just long enough to cause a split to take place.............." +) +return "Hi there. This is areally really reallllly long string that needs to be split!!!" +ternary_expression = ( + "Short String" + if some_condition + else "This is a really long string that will eventually need to be split right here." +) +return f'{x}/b/c/d/d/d/dadfjsadjsaidoaisjdsfjaofjdfijaidfjaodfjaoifjodjafojdoajaaaaaaaaaaa' +return f'{x}/b/c/d/d/d/dadfjsadjsaidoaisjdsfjaofjdfijaidfjaodfjaoifjodjafojdoajaaaaaaaaaaaa' +assert str(result) == "This long string should be split at some point right close to or around hereeeeeee" +assert str(result) < "This long string should be split at some point right close to or around hereeeeee" +assert "A format string: %s" % "This long string should be split at some point right close to or around hereeeeeee" != result +msg += "This long string should be wrapped in parens at some point right around hereeeee" +msg += "This long string should be split at some point right close to or around hereeeeeeee" +msg += "This long string should not be split at any point ever since it is just righttt" + + +# output + + +some_variable = "This string is long but not so long that it needs to be split just yet" +some_variable = "This string is long but not so long that it needs to be split just yet" +some_variable = ( + "This string is long, just long enough that it needs to be split, u get?" +) +some_variable = ( + "This string is long, just long enough that it needs to be split, u get?" +) +some_variable = ( + "This string is long, just long enough that it needs to be split, u get? So we stay" +) +some_variable = ( + "This string is long, just long enough that it needs to be split, u get? So we stay" +) +some_variable = ( + "This string is long, just long enough that it needs to be split, u get? So we" + " split" +) +some_variable = ( + "This string is long, just long enough that it needs to be split, u get? So we" + " split" +) +some_variable = ( + "This string is long but not so long that it needs hahahah toooooo be so greatttt" + " {} that I just can't think of any more good words to say about it at alll".format( + "ha" + ) +) +some_variable = ( + "This string is long but not so long that it needs hahahah toooooo be so greatttt" + " {} that I just can't think of any more good words to say about it at allll" + .format("ha") +) +some_variable = ( + "This string is long but not so long that it needs hahahah toooooo be so greatttt" + " {} that I just can't think of any more good words to say about it at alllllllllll" + .format("ha") +) +some_variable = ( + "This string is long but not so long that it needs hahahah toooooo be so greatttt" + " {} that I just can't think of any more good words to say about it at" + " allllllllllll".format("ha") +) +some_variable = ( + "This is a long string that will end with a method that is not calleddd".format +) +addition_inside_tuple = ( + some_string_inside_a_variable + + "Some string that is just long enough to cause a split to take" + " place.............", + xyz, + "Some really long string that needs to get split eventually but I'm running out of" + " things to say" + + some_string_inside_a_variable, +) +addition_inside_tuple = ( + some_string_inside_a_variable + + "Some string that is just long enough to cause a split to take" + " place.............." +) +return ( + "Hi there. This is areally really reallllly long string that needs to be split!!!" +) +ternary_expression = ( + "Short String" + if some_condition + else ( + "This is a really long string that will eventually need to be split right here." + ) +) +return ( + f"{x}/b/c/d/d/d/dadfjsadjsaidoaisjdsfjaofjdfijaidfjaodfjaoifjodjafojdoajaaaaaaaaaaa" +) +return f"{x}/b/c/d/d/d/dadfjsadjsaidoaisjdsfjaofjdfijaidfjaodfjaoifjodjafojdoajaaaaaaaaaaaa" +assert ( + str(result) + == "This long string should be split at some point right close to or around" + " hereeeeeee" +) +assert ( + str(result) + < "This long string should be split at some point right close to or around" + " hereeeeee" +) +assert ( + "A format string: %s" + % "This long string should be split at some point right close to or around" + " hereeeeeee" + != result +) +msg += ( + "This long string should be wrapped in parens at some point right around hereeeee" +) +msg += ( + "This long string should be split at some point right close to or around" + " hereeeeeeee" +) +msg += "This long string should not be split at any point ever since it is just righttt" diff --git a/tests/data/cases/preview_long_strings__regression.py b/tests/data/cases/preview_long_strings__regression.py new file mode 100644 index 0000000..58fe320 --- /dev/null +++ b/tests/data/cases/preview_long_strings__regression.py @@ -0,0 +1,1270 @@ +# flags: --unstable +class A: + def foo(): + result = type(message)("") + + +# Don't merge multiline (e.g. triple-quoted) strings. +def foo(): + query = ( + """SELECT xxxxxxxxxxxxxxxxxxxx(xxx)""" + """ FROM xxxxxxxxxxxxxxxx WHERE xxxxxxxxxx AND xxx <> xxxxxxxxxxxxxx()""") + +# There was a bug where tuples were being identified as long strings. +long_tuple = ('Apple', 'Berry', 'Cherry', 'Dill', 'Evergreen', 'Fig', + 'Grape', 'Harry', 'Iglu', 'Jaguar') + +stupid_format_method_bug = "Some really long string that just so happens to be the {} {} to force the 'format' method to hang over the line length boundary. This is pretty annoying.".format("perfect", "length") + +class A: + def foo(): + os.system("This is a regression test. xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxxx.".format("xxxxxxxxxx", "xxxxxx", "xxxxxxxxxx")) + + +class A: + def foo(): + XXXXXXXXXXXX.append( + ( + "xxx_xxxxxxxxxx(xxxxx={}, xxxx={}, xxxxx, xxxx_xxxx_xxxxxxxxxx={})".format( + xxxxx, xxxx, xxxx_xxxx_xxxxxxxxxx + ), + my_var, + my_other_var, + ) + ) + +class A: + class B: + def foo(): + bar( + ( + "[{}]: xxx_xxxxxxxxxx(xxxxx={}, xxxx={}, xxxxx={}" + " xxxx_xxxx_xxxxxxxxxx={}, xxxx={})" + .format(xxxx._xxxxxxxxxxxxxx, xxxxx, xxxx, xxxx_xxxx_xxxxxxxxxx, xxxxxxx) + ), + varX, + varY, + varZ, + ) + +def foo(xxxx): + for (xxx_xxxx, _xxx_xxx, _xxx_xxxxx, xxx_xxxx) in xxxx: + for xxx in xxx_xxxx: + assert ("x" in xxx) or ( + xxx in xxx_xxx_xxxxx + ), "{0} xxxxxxx xx {1}, xxx {1} xx xxx xx xxxx xx xxx xxxx: xxx xxxx {2}".format( + xxx_xxxx, xxx, xxxxxx.xxxxxxx(xxx_xxx_xxxxx) + ) + +class A: + def disappearing_comment(): + return ( + ( # xx -x xxxxxxx xx xxx xxxxxxx. + '{{xxx_xxxxxxxxxx_xxxxxxxx}} xxx xxxx' + ' {} {{xxxx}} >&2' + .format( + "{xxxx} {xxxxxx}" + if xxxxx.xx_xxxxxxxxxx + else ( # Disappearing Comment + "--xxxxxxx --xxxxxx=x --xxxxxx-xxxxx=xxxxxx" + " --xxxxxx-xxxx=xxxxxxxxxxx.xxx" + ) + ) + ), + (x, y, z), + ) + +class A: + class B: + def foo(): + xxxxx_xxxx( + xx, "\t" + "@xxxxxx '{xxxx_xxx}\t' > {xxxxxx_xxxx}.xxxxxxx;" + "{xxxx_xxx} >> {xxxxxx_xxxx}.xxxxxxx 2>&1; xx=$$?;" + "xxxx $$xx" + .format(xxxx_xxx=xxxx_xxxxxxx, xxxxxx_xxxx=xxxxxxx + "/" + xxxx_xxx_xxxx, x=xxx_xxxxx_xxxxx_xxx), + x, + y, + z, + ) + +func_call_where_string_arg_has_method_call_and_bad_parens( + ( + "A long string with {}. This string is so long that it is ridiculous. It can't fit on one line at alllll.".format("formatting") + ), +) + +func_call_where_string_arg_has_old_fmt_and_bad_parens( + ( + "A long string with {}. This string is so long that it is ridiculous. It can't fit on one line at alllll." % "formatting" + ), +) + +func_call_where_string_arg_has_old_fmt_and_bad_parens( + ( + "A long string with {}. This {} is so long that it is ridiculous. It can't fit on one line at alllll." % ("formatting", "string") + ), +) + +class A: + def append(self): + if True: + xxxx.xxxxxxx.xxxxx( ('xxxxxxxxxx xxxx xx xxxxxx(%x) xx %x xxxx xx xxx %x.xx' + % (len(self) + 1, + xxxx.xxxxxxxxxx, + xxxx.xxxxxxxxxx)) + + (' %.3f (%s) to %.3f (%s).\n' + % (xxxx.xxxxxxxxx, + xxxx.xxxxxxxxxxxxxx(xxxx.xxxxxxxxx), + x, + xxxx.xxxxxxxxxxxxxx( xx) + ))) + +class A: + def foo(): + some_func_call( + 'xxxxxxxxxx', + ( + "xx {xxxxxxxxxxx}/xxxxxxxxxxx.xxx xxxx.xxx && xxxxxx -x " + "\"xxxx xxxxxxx xxxxxx xxxx; xxxx xxxxxx_xxxxx xxxxxx xxxx; " + "xxxx.xxxx_xxxxxx(['xxxx.xxx'], xxxx.xxxxxxx().xxxxxxxxxx)\" " + ), + None, + ('xxxxxxxxxxx',), + ), + +class A: + def foo(): + some_func_call( + ( + "xx {xxxxxxxxxxx}/xxxxxxxxxxx.xxx xxxx.xxx && xxxxxx -x " + "xxxx, ('xxxxxxx xxxxxx xxxx, xxxx') xxxxxx_xxxxx xxxxxx xxxx; " + "xxxx.xxxx_xxxxxx(['xxxx.xxx'], xxxx.xxxxxxx().xxxxxxxxxx)\" " + ), + None, + ('xxxxxxxxxxx',), + ), + +xxxxxxx = { 'xx' : 'xxxx xxxxxxx xxxxxxxxx -x xxx -x /xxx/{0} -x xxx,xxx -xx {1} \ +-xx {1} -xx xxx=xxx_xxxx,xxx_xx,xxx_xxx,xxx_xxxx,xxx_xx,xxx_xxx |\ + xxxxxx -x xxxxxxxx -x xxxxxxxx -x', + 'xx' : 'xxxx xxxxxxx xxxxxxxxx -x xxx -x /xxx/{0} -x xxx,xxx -xx {1} \ +-xx {1} -xx xxx=xxx_xxxx_xxx_xxxx,xxx_xx_xxx_xxxx,xxx_xxxx_xxx_xxxx,\ +xxx_xx_xxxx_xxxx,xxx_xxx_xxxx,xxx_xxx_xxxx xxxx=xxx | xxxxxx -x xxxxxxxx -x xxxxxxxx -x' +} + +class A: + def foo(self): + if True: + xxxxx_xxxxxxxxxxxx('xxx xxxxxx xxx xxxxxxxxx.xx xx xxxxxxxx. xxx xxxxxxxxxxxxx.xx xxxxxxx ' + + 'xx xxxxxx xxxxxx xxxxxx xx xxxxxxx xxx xxx ${0} xx x xxxxxxxx xxxxx'.xxxxxx(xxxxxx_xxxxxx_xxx)) + +class A: + class B: + def foo(): + row = { + 'xxxxxxxxxxxxxxx' : xxxxxx_xxxxx_xxxx, + # 'xxxxxxxxxxxxxxxxxxxxxxx' + # 'xxxxxxxxxxxxxxxxxxxxxx' + # 'xxxxxxxxxxxxxxxxxx' + # 'xxxxxxxxxxxxxxxxx' + 'xxxxxxxxxx' : xxxxx_xxxxx, + } + +class A: + def xxxx_xxx_xx_xxxxxxxxxx_xxxx_xxxxxxxxx(xxxx): + xxxxxxxx = [ + xxxxxxxxxxxxxxxx( + 'xxxx', + xxxxxxxxxxx={ + 'xxxx' : 1.0, + }, + xxxxxx={'xxxxxx 1' : xxxxxx(xxxx='xxxxxx 1', xxxxxx=600.0)}, + xxxxxxxx_xxxxxxx=0.0, + ), + xxxxxxxxxxxxxxxx( + 'xxxxxxx', + xxxxxxxxxxx={ + 'xxxx' : 1.0, + }, + xxxxxx={'xxxxxx 1' : xxxxxx(xxxx='xxxxxx 1', xxxxxx=200.0)}, + xxxxxxxx_xxxxxxx=0.0, + ), + xxxxxxxxxxxxxxxx( + 'xxxx', + ), + ] + +some_dictionary = { + 'xxxxx006': ['xxx-xxx xxxxx3xxxx1xx2xxxxxxxxxxxxxx0xx6xxxxxxxxxx2xxxxxx9xxxxxxxxxx0xxxxx1xxx2x/xx9xx6+x+xxxxxxxxxxxxxx4xxxxxxxxxxxxxxxxxxxxx43xxx2xx2x4x++xxx6xxxxxxxxx+xxxxx/xx9x+xxxxxxxxxxxxxx8x15xxxxxxxxxxxxxxxxx82xx/xxxxxxxxxxxxxx/x5xxxxxxxxxxxxxx6xxxxxx74x4/xxx4x+xxxxxxxxx2xxxxxxxx87xxxxx4xxxxxxxx3xx0xxxxx4xxx1xx9xx5xxxxxxx/xxxxx5xx6xx4xxxx1x/x2xxxxxxxxxxxx64xxxxxxx1x0xx5xxxxxxxxxxxxxx== xxxxx000 xxxxxxxxxx\n', + 'xxx-xxx xxxxx3xxxx1xx2xxxxxxxxxxxxxx6xxxxxxxxxxxxxx9xxxxxxxxxxxxx3xxx9xxxxxxxxxxxxxxxx0xxxxxxxxxxxxxxxxx2xxxx2xxx6xxxxx/xx54xxxxxxxxx4xxx3xxxxxx9xx3xxxxx39xxxxxxxxx5xx91xxxx7xxxxxx8xxxxxxxxxxxxxxxx9xxx93xxxxxxxxxxxxxxxxx7xxx8xx8xx4/x1xxxxx1x3xxxxxxxxxxxxx3xxxxxx9xx4xx4x7xxxxxxxxxxxxx1xxxxxxxxx7xxxxxxxxxxxxxx4xx6xxxxxxxxx9xxx7xxxx2xxxxxxxxxxxxxxxxxxxxxx8xxxxxxxxxxxxxxxxxxxx6xx== xxxxx010 xxxxxxxxxx\n'], + 'xxxxx016': ['xxx-xxx xxxxx3xxxx1xx2xxxxxxxxxxxxxx0xx6xxxxxxxxxx2xxxxxx9xxxxxxxxxx0xxxxx1xxx2x/xx9xx6+x+xxxxxxxxxxxxxx4xxxxxxxxxxxxxxxxxxxxx43xxx2xx2x4x++xxx6xxxxxxxxx+xxxxx/xx9x+xxxxxxxxxxxxxx8x15xxxxxxxxxxxxxxxxx82xx/xxxxxxxxxxxxxx/x5xxxxxxxxxxxxxx6xxxxxx74x4/xxx4x+xxxxxxxxx2xxxxxxxx87xxxxx4xxxxxxxx3xx0xxxxx4xxx1xx9xx5xxxxxxx/xxxxx5xx6xx4xxxx1x/x2xxxxxxxxxxxx64xxxxxxx1x0xx5xxxxxxxxxxxxxx== xxxxx000 xxxxxxxxxx\n', + 'xxx-xxx xxxxx3xxxx1xx2xxxxxxxxxxxxxx6xxxxxxxxxxxxxx9xxxxxxxxxxxxx3xxx9xxxxxxxxxxxxxxxx0xxxxxxxxxxxxxxxxx2xxxx2xxx6xxxxx/xx54xxxxxxxxx4xxx3xxxxxx9xx3xxxxx39xxxxxxxxx5xx91xxxx7xxxxxx8xxxxxxxxxxxxxxxx9xxx93xxxxxxxxxxxxxxxxx7xxx8xx8xx4/x1xxxxx1x3xxxxxxxxxxxxx3xxxxxx9xx4xx4x7xxxxxxxxxxxxx1xxxxxxxxx7xxxxxxxxxxxxxx4xx6xxxxxxxxx9xxx7xxxx2xxxxxxxxxxxxxxxxxxxxxx8xxxxxxxxxxxxxxxxxxxx6xx== xxxxx010 xxxxxxxxxx\n'] +} + +def foo(): + xxx_xxx = ( + 'xxxx xxx xxxxxxxx_xxxx xx "xxxxxxxxxx".' + '\n xxx: xxxxxx xxxxxxxx_xxxx=xxxxxxxxxx' + ) # xxxx xxxxxxxxxx xxxx xx xxxx xx xxx xxxxxxxx xxxxxx xxxxx. + +some_tuple = ("some string", "some string" " which should be joined") + +some_commented_string = ( # This comment stays at the top. + "This string is long but not so long that it needs hahahah toooooo be so greatttt" + " {} that I just can't think of any more good words to say about it at" + " allllllllllll".format("ha") # comments here are fine +) + +some_commented_string = ( + "This string is long but not so long that it needs hahahah toooooo be so greatttt" # But these + " {} that I just can't think of any more good words to say about it at" # comments will stay + " allllllllllll".format("ha") # comments here are fine +) + +lpar_and_rpar_have_comments = func_call( # LPAR Comment + "Long really ridiculous type of string that shouldn't really even exist at all. I mean commmme onnn!!!", # Comma Comment +) # RPAR Comment + +cmd_fstring = ( + f"sudo -E deluge-console info --detailed --sort-reverse=time_added " + f"{'' if ID is None else ID} | perl -nE 'print if /^{field}:/'" +) + +cmd_fstring = f"sudo -E deluge-console info --detailed --sort-reverse=time_added {'' if ID is None else ID} | perl -nE 'print if /^{field}:/'" + +cmd_fstring = f"sudo -E deluge-console info --detailed --sort-reverse=time_added {'{{}}' if ID is None else ID} | perl -nE 'print if /^{field}:/'" + +cmd_fstring = f"sudo -E deluge-console info --detailed --sort-reverse=time_added {{'' if ID is None else ID}} | perl -nE 'print if /^{field}:/'" + +fstring = f"This string really doesn't need to be an {{{{fstring}}}}, but this one most certainly, absolutely {does}." + +fstring = ( + f"We have to remember to escape {braces}." + " Like {these}." + f" But not {this}." +) + +class A: + class B: + def foo(): + st_error = STError( + f"This string ({string_leaf.value}) appears to be pointless (i.e. has" + " no parent)." + ) + +def foo(): + user_regex = _lazy_re_compile( + r"(^[-!#$%&'*+/=?^_`{}|~0-9A-Z]+(\.[-!#$%&'*+/=?^_`{}|~0-9A-Z]+)*\Z" # dot-atom + r'|^"([\001-\010\013\014\016-\037!#-\[\]-\177]|\\[\001-\011\013\014\016-\177])*"\Z)', # quoted-string + re.IGNORECASE) + +def foo(): + user_regex = _lazy_re_compile( + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" # dot-atom + 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx', # quoted-string + xyz + ) + +def foo(): + user_regex = _lazy_re_compile( + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" # dot-atom + 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx', # quoted-string + xyz + ) + +class A: + class B: + def foo(): + if not hasattr(module, name): + raise ValueError( + "Could not find object %s in %s.\n" + "Please note that you cannot serialize things like inner " + "classes. Please move the object into the main module " + "body to use migrations.\n" + "For more information, see " + "https://docs.djangoproject.com/en/%s/topics/migrations/#serializing-values" + % (name, module_name, get_docs_version())) + +class A: + class B: + def foo(): + if not hasattr(module, name): + raise ValueError( + "Could not find object %s in %s.\nPlease note that you cannot serialize things like inner classes. Please move the object into the main module body to use migrations.\nFor more information, see https://docs.djangoproject.com/en/%s/topics/migrations/#serializing-values" + % (name, module_name, get_docs_version())) + +x = ( + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +) + +class Step(StepBase): + def who(self): + self.cmd = 'SR AAAA-CORRECT NAME IS {last_name} {first_name}{middle_name} {title}/P{passenger_association}'.format( + last_name=last_name, + first_name=first_name, + middle_name=middle_name, + title=title, + passenger_association=passenger_association, + ) + +xxxxxxx_xxxxxx_xxxxxxx = xxx( + [ + xxxxxxxxxxxx( + xxxxxx_xxxxxxx=( + '((x.aaaaaaaaa = "xxxxxx.xxxxxxxxxxxxxxxxxxxxx") || (x.xxxxxxxxx = "xxxxxxxxxxxx")) && ' + # xxxxx xxxxxxxxxxxx xxxx xxx (xxxxxxxxxxxxxxxx) xx x xxxxxxxxx xx xxxxxx. + "(x.bbbbbbbbbbbb.xxx != " + '"xxx:xxx:xxx::cccccccccccc:xxxxxxx-xxxx/xxxxxxxxxxx/xxxxxxxxxxxxxxxxx") && ' + ) + ) + ] +) + +if __name__ == "__main__": + for i in range(4, 8): + cmd = ( + r"for pid in $(ps aux | grep paster | grep -v grep | grep '\-%d' | awk '{print $2}'); do kill $pid; done" + % (i) + ) + +def A(): + def B(): + def C(): + def D(): + def E(): + def F(): + def G(): + assert ( + c_float(val[0][0] / val[0][1]).value + == c_float(value[0][0] / value[0][1]).value + ), "%s didn't roundtrip" % tag + +class xxxxxxxxxxxxxxxxxxxxx(xxxx.xxxxxxxxxxxxx): + def xxxxxxx_xxxxxx(xxxx): + assert xxxxxxx_xxxx in [ + x.xxxxx.xxxxxx.xxxxx.xxxxxx, + x.xxxxx.xxxxxx.xxxxx.xxxx, + ], ("xxxxxxxxxxx xxxxxxx xxxx (xxxxxx xxxx) %x xxx xxxxx" % xxxxxxx_xxxx) + +value.__dict__[ + key +] = "test" # set some Thrift field to non-None in the struct aa bb cc dd ee + +RE_ONE_BACKSLASH = { + "asdf_hjkl_jkl": re.compile( + r"(?>\n" +) + +assert str(suffix_arr) == ( + "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', " + "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', " + "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']" +) +assert str(suffix_arr) != ( + "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', " + "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', " + "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']" +) +assert str(suffix_arr) <= ( + "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', " + "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', " + "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']" +) +assert str(suffix_arr) >= ( + "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', " + "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', " + "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']" +) +assert str(suffix_arr) < ( + "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', " + "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', " + "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']" +) +assert str(suffix_arr) > ( + "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', " + "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', " + "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']" +) +assert str(suffix_arr) in "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', 'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', 'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']" +assert str(suffix_arr) not in "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', 'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', 'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']" +message = ( + f"1. Go to Google Developers Console and log in with your Google account." + "(https://console.developers.google.com/)" + "2. You should be prompted to create a new project (name does not matter)." + "3. Click on Enable APIs and Services at the top." + "4. In the list of APIs choose or search for YouTube Data API v3 and " + "click on it. Choose Enable." + "5. Click on Credentials on the left navigation bar." + "6. Click on Create Credential at the top." + '7. At the top click the link for "API key".' + "8. No application restrictions are needed. Click Create at the bottom." + "9. You now have a key to add to `{prefix}set api youtube api_key`" +) +message = ( + f"1. Go to Google Developers Console and log in with your Google account." + "(https://console.developers.google.com/)" + "2. You should be prompted to create a new project (name does not matter)." + f"3. Click on Enable APIs and Services at the top." + "4. In the list of APIs choose or search for YouTube Data API v3 and " + "click on it. Choose Enable." + f"5. Click on Credentials on the left navigation bar." + "6. Click on Create Credential at the top." + '7. At the top click the link for "API key".' + "8. No application restrictions are needed. Click Create at the bottom." + "9. You now have a key to add to `{prefix}set api youtube api_key`" +) +message = ( + f"1. Go to Google Developers Console and log in with your Google account." + "(https://console.developers.google.com/)" + "2. You should be prompted to create a new project (name does not matter)." + f"3. Click on Enable APIs and Services at the top." + "4. In the list of APIs choose or search for YouTube Data API v3 and " + "click on it. Choose Enable." + f"5. Click on Credentials on the left navigation bar." + "6. Click on Create Credential at the top." + '7. At the top click the link for "API key".' + "8. No application restrictions are needed. Click Create at the bottom." + f"9. You now have a key to add to `{prefix}set api youtube api_key`" +) + +# It shouldn't matter if the string prefixes are capitalized. +temp_msg = ( + F"{F'{humanize_number(pos)}.': <{pound_len+2}} " + F"{balance: <{bal_len + 5}} " + F"<<{author.display_name}>>\n" +) + +fstring = ( + F"We have to remember to escape {braces}." + " Like {these}." + F" But not {this}." +) + +welcome_to_programming = R"hello," R" world!" + +fstring = F"f-strings definitely make things more {difficult} than they need to be for {{black}}. But boy they sure are handy. The problem is that some lines will need to have the 'f' whereas others do not. This {line}, for example, needs one." + +x = F"This is a long string which contains an f-expr that should not split {{{[i for i in range(5)]}}}." + +x = ( + "\N{BLACK RIGHT-POINTING TRIANGLE WITH DOUBLE VERTICAL BAR}\N{VARIATION SELECTOR-16}" +) + +xxxxxx_xxx_xxxx_xx_xxxxx_xxxxxxxx_xxxxxxxx_xxxxxxxxxx_xxxx_xxxx_xxxxx = xxxx.xxxxxx.xxxxxxxxx.xxxxxxxxxxxxxxxxxxxx( + xx_xxxxxx={ + "x3_xxxxxxxx": "xxx3_xxxxx_xxxxxxxx_xxxxxxxx_xxxxxxxxxx_xxxxxxxx_xxxxxx_xxxxxxx", + }, +) + +# Regression test for https://github.com/psf/black/issues/3117. +some_dict = { + "something_something": + r"Lorem ipsum dolor sit amet, an sed convenire eloquentiam \t" + r"signiferumque, duo ea vocibus consetetur scriptorem. Facer \t", +} + +# Regression test for https://github.com/psf/black/issues/3459. +xxxx( + empty_str_as_first_split='' + f'xxxxxxx {xxxxxxxxxx} xxx xxxxxxxxxx xxxxx xxx xxx xx ' + 'xxxxx xxxxxxxxx xxxxxxx, xxx xxxxxxxxxxx xxx xxxxx. ' + f'xxxxxxxxxxxxx xxxx xx xxxxxxxxxx. xxxxx: {x.xxx}', + empty_u_str_as_first_split=u'' + f'xxxxxxx {xxxxxxxxxx} xxx xxxxxxxxxx xxxxx xxx xxx xx ' + 'xxxxx xxxxxxxxx xxxxxxx, xxx xxxxxxxxxxx xxx xxxxx. ' + f'xxxxxxxxxxxxx xxxx xx xxxxxxxxxx. xxxxx: {x.xxx}', +) + +# Regression test for https://github.com/psf/black/issues/3455. +a_dict = { + "/this/is/a/very/very/very/very/very/very/very/very/very/very/long/key/without/spaces": + # And there is a comment before the value + ("item1", "item2", "item3"), +} + +# Regression test for https://github.com/psf/black/issues/3506. +# Regressed again by https://github.com/psf/black/pull/4498 +s = ( + "With single quote: ' " + f" {my_dict['foo']}" + ' With double quote: " ' + f' {my_dict["bar"]}' +) + +s = f'Lorem Ipsum is simply dummy text of the printing and typesetting industry:\'{my_dict["foo"]}\'' + +# Regression test for https://github.com/psf/black/issues/4510. +# Don't merge multi-line strings when a pragma comment follows. +( + "A very very very very very very very very very very very very long string " + "annotated with a type ignore pragma gets merged into a single very long line " + "which is against the line length rule." +) # type: ignore + + +# output + + +class A: + def foo(): + result = type(message)("") + + +# Don't merge multiline (e.g. triple-quoted) strings. +def foo(): + query = ( + """SELECT xxxxxxxxxxxxxxxxxxxx(xxx)""" + """ FROM xxxxxxxxxxxxxxxx WHERE xxxxxxxxxx AND xxx <> xxxxxxxxxxxxxx()""" + ) + + +# There was a bug where tuples were being identified as long strings. +long_tuple = ( + "Apple", + "Berry", + "Cherry", + "Dill", + "Evergreen", + "Fig", + "Grape", + "Harry", + "Iglu", + "Jaguar", +) + +stupid_format_method_bug = ( + "Some really long string that just so happens to be the {} {} to force the 'format'" + " method to hang over the line length boundary. This is pretty annoying.".format( + "perfect", "length" + ) +) + + +class A: + def foo(): + os.system( + "This is a regression test. xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx" + " xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx" + " xxxx.".format("xxxxxxxxxx", "xxxxxx", "xxxxxxxxxx") + ) + + +class A: + def foo(): + XXXXXXXXXXXX.append(( + "xxx_xxxxxxxxxx(xxxxx={}, xxxx={}, xxxxx, xxxx_xxxx_xxxxxxxxxx={})".format( + xxxxx, xxxx, xxxx_xxxx_xxxxxxxxxx + ), + my_var, + my_other_var, + )) + + +class A: + class B: + def foo(): + bar( + "[{}]: xxx_xxxxxxxxxx(xxxxx={}, xxxx={}, xxxxx={}" + " xxxx_xxxx_xxxxxxxxxx={}, xxxx={})".format( + xxxx._xxxxxxxxxxxxxx, xxxxx, xxxx, xxxx_xxxx_xxxxxxxxxx, xxxxxxx + ), + varX, + varY, + varZ, + ) + + +def foo(xxxx): + for xxx_xxxx, _xxx_xxx, _xxx_xxxxx, xxx_xxxx in xxxx: + for xxx in xxx_xxxx: + assert ("x" in xxx) or (xxx in xxx_xxx_xxxxx), ( + "{0} xxxxxxx xx {1}, xxx {1} xx xxx xx xxxx xx xxx xxxx: xxx xxxx {2}" + .format(xxx_xxxx, xxx, xxxxxx.xxxxxxx(xxx_xxx_xxxxx)) + ) + + +class A: + def disappearing_comment(): + return ( + ( # xx -x xxxxxxx xx xxx xxxxxxx. + "{{xxx_xxxxxxxxxx_xxxxxxxx}} xxx xxxx {} {{xxxx}} >&2".format( + "{xxxx} {xxxxxx}" + if xxxxx.xx_xxxxxxxxxx + else ( # Disappearing Comment + "--xxxxxxx --xxxxxx=x --xxxxxx-xxxxx=xxxxxx" + " --xxxxxx-xxxx=xxxxxxxxxxx.xxx" + ) + ) + ), + (x, y, z), + ) + + +class A: + class B: + def foo(): + xxxxx_xxxx( + xx, + "\t" + "@xxxxxx '{xxxx_xxx}\t' > {xxxxxx_xxxx}.xxxxxxx;" + "{xxxx_xxx} >> {xxxxxx_xxxx}.xxxxxxx 2>&1; xx=$$?;" + "xxxx $$xx".format( + xxxx_xxx=xxxx_xxxxxxx, + xxxxxx_xxxx=xxxxxxx + "/" + xxxx_xxx_xxxx, + x=xxx_xxxxx_xxxxx_xxx, + ), + x, + y, + z, + ) + + +func_call_where_string_arg_has_method_call_and_bad_parens( + "A long string with {}. This string is so long that it is ridiculous. It can't fit" + " on one line at alllll.".format("formatting"), +) + +func_call_where_string_arg_has_old_fmt_and_bad_parens( + "A long string with {}. This string is so long that it is ridiculous. It can't fit" + " on one line at alllll." % "formatting", +) + +func_call_where_string_arg_has_old_fmt_and_bad_parens( + "A long string with {}. This {} is so long that it is ridiculous. It can't fit on" + " one line at alllll." % ("formatting", "string"), +) + + +class A: + def append(self): + if True: + xxxx.xxxxxxx.xxxxx( + "xxxxxxxxxx xxxx xx xxxxxx(%x) xx %x xxxx xx xxx %x.xx" + % (len(self) + 1, xxxx.xxxxxxxxxx, xxxx.xxxxxxxxxx) + + " %.3f (%s) to %.3f (%s).\n" + % ( + xxxx.xxxxxxxxx, + xxxx.xxxxxxxxxxxxxx(xxxx.xxxxxxxxx), + x, + xxxx.xxxxxxxxxxxxxx(xx), + ) + ) + + +class A: + def foo(): + some_func_call( + "xxxxxxxxxx", + "xx {xxxxxxxxxxx}/xxxxxxxxxxx.xxx xxxx.xxx && xxxxxx -x " + '"xxxx xxxxxxx xxxxxx xxxx; xxxx xxxxxx_xxxxx xxxxxx xxxx; ' + "xxxx.xxxx_xxxxxx(['xxxx.xxx'], xxxx.xxxxxxx().xxxxxxxxxx)\" ", + None, + ("xxxxxxxxxxx",), + ), + + +class A: + def foo(): + some_func_call( + "xx {xxxxxxxxxxx}/xxxxxxxxxxx.xxx xxxx.xxx && xxxxxx -x " + "xxxx, ('xxxxxxx xxxxxx xxxx, xxxx') xxxxxx_xxxxx xxxxxx xxxx; " + "xxxx.xxxx_xxxxxx(['xxxx.xxx'], xxxx.xxxxxxx().xxxxxxxxxx)\" ", + None, + ("xxxxxxxxxxx",), + ), + + +xxxxxxx = { + "xx": ( + "xxxx xxxxxxx xxxxxxxxx -x xxx -x /xxx/{0} -x xxx,xxx -xx {1} -xx {1} -xx" + " xxx=xxx_xxxx,xxx_xx,xxx_xxx,xxx_xxxx,xxx_xx,xxx_xxx | xxxxxx -x xxxxxxxx -x" + " xxxxxxxx -x" + ), + "xx": ( + "xxxx xxxxxxx xxxxxxxxx -x xxx -x /xxx/{0} -x xxx,xxx -xx {1} -xx {1} -xx" + " xxx=xxx_xxxx_xxx_xxxx,xxx_xx_xxx_xxxx,xxx_xxxx_xxx_xxxx,xxx_xx_xxxx_xxxx,xxx_xxx_xxxx,xxx_xxx_xxxx" + " xxxx=xxx | xxxxxx -x xxxxxxxx -x xxxxxxxx -x" + ), +} + + +class A: + def foo(self): + if True: + xxxxx_xxxxxxxxxxxx( + "xxx xxxxxx xxx xxxxxxxxx.xx xx xxxxxxxx. xxx xxxxxxxxxxxxx.xx" + " xxxxxxx " + + "xx xxxxxx xxxxxx xxxxxx xx xxxxxxx xxx xxx ${0} xx x xxxxxxxx xxxxx" + .xxxxxx(xxxxxx_xxxxxx_xxx) + ) + + +class A: + class B: + def foo(): + row = { + "xxxxxxxxxxxxxxx": xxxxxx_xxxxx_xxxx, + # 'xxxxxxxxxxxxxxxxxxxxxxx' + # 'xxxxxxxxxxxxxxxxxxxxxx' + # 'xxxxxxxxxxxxxxxxxx' + # 'xxxxxxxxxxxxxxxxx' + "xxxxxxxxxx": xxxxx_xxxxx, + } + + +class A: + def xxxx_xxx_xx_xxxxxxxxxx_xxxx_xxxxxxxxx(xxxx): + xxxxxxxx = [ + xxxxxxxxxxxxxxxx( + "xxxx", + xxxxxxxxxxx={ + "xxxx": 1.0, + }, + xxxxxx={"xxxxxx 1": xxxxxx(xxxx="xxxxxx 1", xxxxxx=600.0)}, + xxxxxxxx_xxxxxxx=0.0, + ), + xxxxxxxxxxxxxxxx( + "xxxxxxx", + xxxxxxxxxxx={ + "xxxx": 1.0, + }, + xxxxxx={"xxxxxx 1": xxxxxx(xxxx="xxxxxx 1", xxxxxx=200.0)}, + xxxxxxxx_xxxxxxx=0.0, + ), + xxxxxxxxxxxxxxxx( + "xxxx", + ), + ] + + +some_dictionary = { + "xxxxx006": [ + ( + "xxx-xxx" + " xxxxx3xxxx1xx2xxxxxxxxxxxxxx0xx6xxxxxxxxxx2xxxxxx9xxxxxxxxxx0xxxxx1xxx2x/xx9xx6+x+xxxxxxxxxxxxxx4xxxxxxxxxxxxxxxxxxxxx43xxx2xx2x4x++xxx6xxxxxxxxx+xxxxx/xx9x+xxxxxxxxxxxxxx8x15xxxxxxxxxxxxxxxxx82xx/xxxxxxxxxxxxxx/x5xxxxxxxxxxxxxx6xxxxxx74x4/xxx4x+xxxxxxxxx2xxxxxxxx87xxxxx4xxxxxxxx3xx0xxxxx4xxx1xx9xx5xxxxxxx/xxxxx5xx6xx4xxxx1x/x2xxxxxxxxxxxx64xxxxxxx1x0xx5xxxxxxxxxxxxxx==" + " xxxxx000 xxxxxxxxxx\n" + ), + ( + "xxx-xxx" + " xxxxx3xxxx1xx2xxxxxxxxxxxxxx6xxxxxxxxxxxxxx9xxxxxxxxxxxxx3xxx9xxxxxxxxxxxxxxxx0xxxxxxxxxxxxxxxxx2xxxx2xxx6xxxxx/xx54xxxxxxxxx4xxx3xxxxxx9xx3xxxxx39xxxxxxxxx5xx91xxxx7xxxxxx8xxxxxxxxxxxxxxxx9xxx93xxxxxxxxxxxxxxxxx7xxx8xx8xx4/x1xxxxx1x3xxxxxxxxxxxxx3xxxxxx9xx4xx4x7xxxxxxxxxxxxx1xxxxxxxxx7xxxxxxxxxxxxxx4xx6xxxxxxxxx9xxx7xxxx2xxxxxxxxxxxxxxxxxxxxxx8xxxxxxxxxxxxxxxxxxxx6xx==" + " xxxxx010 xxxxxxxxxx\n" + ), + ], + "xxxxx016": [ + ( + "xxx-xxx" + " xxxxx3xxxx1xx2xxxxxxxxxxxxxx0xx6xxxxxxxxxx2xxxxxx9xxxxxxxxxx0xxxxx1xxx2x/xx9xx6+x+xxxxxxxxxxxxxx4xxxxxxxxxxxxxxxxxxxxx43xxx2xx2x4x++xxx6xxxxxxxxx+xxxxx/xx9x+xxxxxxxxxxxxxx8x15xxxxxxxxxxxxxxxxx82xx/xxxxxxxxxxxxxx/x5xxxxxxxxxxxxxx6xxxxxx74x4/xxx4x+xxxxxxxxx2xxxxxxxx87xxxxx4xxxxxxxx3xx0xxxxx4xxx1xx9xx5xxxxxxx/xxxxx5xx6xx4xxxx1x/x2xxxxxxxxxxxx64xxxxxxx1x0xx5xxxxxxxxxxxxxx==" + " xxxxx000 xxxxxxxxxx\n" + ), + ( + "xxx-xxx" + " xxxxx3xxxx1xx2xxxxxxxxxxxxxx6xxxxxxxxxxxxxx9xxxxxxxxxxxxx3xxx9xxxxxxxxxxxxxxxx0xxxxxxxxxxxxxxxxx2xxxx2xxx6xxxxx/xx54xxxxxxxxx4xxx3xxxxxx9xx3xxxxx39xxxxxxxxx5xx91xxxx7xxxxxx8xxxxxxxxxxxxxxxx9xxx93xxxxxxxxxxxxxxxxx7xxx8xx8xx4/x1xxxxx1x3xxxxxxxxxxxxx3xxxxxx9xx4xx4x7xxxxxxxxxxxxx1xxxxxxxxx7xxxxxxxxxxxxxx4xx6xxxxxxxxx9xxx7xxxx2xxxxxxxxxxxxxxxxxxxxxx8xxxxxxxxxxxxxxxxxxxx6xx==" + " xxxxx010 xxxxxxxxxx\n" + ), + ], +} + + +def foo(): + xxx_xxx = ( # xxxx xxxxxxxxxx xxxx xx xxxx xx xxx xxxxxxxx xxxxxx xxxxx. + 'xxxx xxx xxxxxxxx_xxxx xx "xxxxxxxxxx".\n xxx: xxxxxx xxxxxxxx_xxxx=xxxxxxxxxx' + ) + + +some_tuple = ("some string", "some string which should be joined") + +some_commented_string = ( # This comment stays at the top. + "This string is long but not so long that it needs hahahah toooooo be so greatttt" + " {} that I just can't think of any more good words to say about it at" + " allllllllllll".format("ha") # comments here are fine +) + +some_commented_string = ( + "This string is long but not so long that it needs hahahah toooooo be so greatttt" # But these + " {} that I just can't think of any more good words to say about it at" # comments will stay + " allllllllllll".format("ha") # comments here are fine +) + +lpar_and_rpar_have_comments = func_call( # LPAR Comment + "Long really ridiculous type of string that shouldn't really even exist at all. I" + " mean commmme onnn!!!", # Comma Comment +) # RPAR Comment + +cmd_fstring = ( + "sudo -E deluge-console info --detailed --sort-reverse=time_added " + f"{'' if ID is None else ID} | perl -nE 'print if /^{field}:/'" +) + +cmd_fstring = ( + "sudo -E deluge-console info --detailed --sort-reverse=time_added" + f" {'' if ID is None else ID} | perl -nE 'print if /^{field}:/'" +) + +cmd_fstring = ( + "sudo -E deluge-console info --detailed --sort-reverse=time_added" + f" {'{{}}' if ID is None else ID} | perl -nE 'print if /^{field}:/'" +) + +cmd_fstring = ( + "sudo -E deluge-console info --detailed --sort-reverse=time_added {'' if ID is" + f" None else ID}} | perl -nE 'print if /^{field}:/'" +) + +fstring = ( + "This string really doesn't need to be an {{fstring}}, but this one most" + f" certainly, absolutely {does}." +) + +fstring = f"We have to remember to escape {braces}. Like {{these}}. But not {this}." + + +class A: + class B: + def foo(): + st_error = STError( + f"This string ({string_leaf.value}) appears to be pointless (i.e. has" + " no parent)." + ) + + +def foo(): + user_regex = _lazy_re_compile( + r"(^[-!#$%&'*+/=?^_`{}|~0-9A-Z]+(\.[-!#$%&'*+/=?^_`{}|~0-9A-Z]+)*\Z" # dot-atom + r'|^"([\001-\010\013\014\016-\037!#-\[\]-\177]|\\[\001-\011\013\014\016-\177])*"\Z)', # quoted-string + re.IGNORECASE, + ) + + +def foo(): + user_regex = _lazy_re_compile( + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" # dot-atom + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", # quoted-string + xyz, + ) + + +def foo(): + user_regex = _lazy_re_compile( + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" # dot-atom + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", # quoted-string + xyz, + ) + + +class A: + class B: + def foo(): + if not hasattr(module, name): + raise ValueError( + "Could not find object %s in %s.\n" + "Please note that you cannot serialize things like inner " + "classes. Please move the object into the main module " + "body to use migrations.\n" + "For more information, see " + "https://docs.djangoproject.com/en/%s/topics/migrations/#serializing-values" + % (name, module_name, get_docs_version()) + ) + + +class A: + class B: + def foo(): + if not hasattr(module, name): + raise ValueError( + "Could not find object %s in %s.\nPlease note that you cannot" + " serialize things like inner classes. Please move the object into" + " the main module body to use migrations.\nFor more information," + " see https://docs.djangoproject.com/en/%s/topics/migrations/#serializing-values" + % (name, module_name, get_docs_version()) + ) + + +x = ( + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +) + + +class Step(StepBase): + def who(self): + self.cmd = ( + "SR AAAA-CORRECT NAME IS {last_name} {first_name}{middle_name}" + " {title}/P{passenger_association}".format( + last_name=last_name, + first_name=first_name, + middle_name=middle_name, + title=title, + passenger_association=passenger_association, + ) + ) + + +xxxxxxx_xxxxxx_xxxxxxx = xxx([ + xxxxxxxxxxxx( + xxxxxx_xxxxxxx=( + '((x.aaaaaaaaa = "xxxxxx.xxxxxxxxxxxxxxxxxxxxx") || (x.xxxxxxxxx =' + ' "xxxxxxxxxxxx")) && ' + # xxxxx xxxxxxxxxxxx xxxx xxx (xxxxxxxxxxxxxxxx) xx x xxxxxxxxx xx xxxxxx. + "(x.bbbbbbbbbbbb.xxx != " + '"xxx:xxx:xxx::cccccccccccc:xxxxxxx-xxxx/xxxxxxxxxxx/xxxxxxxxxxxxxxxxx") && ' + ) + ) +]) + +if __name__ == "__main__": + for i in range(4, 8): + cmd = ( + r"for pid in $(ps aux | grep paster | grep -v grep | grep '\-%d' | awk" + r" '{print $2}'); do kill $pid; done" % (i) + ) + + +def A(): + def B(): + def C(): + def D(): + def E(): + def F(): + def G(): + assert ( + c_float(val[0][0] / val[0][1]).value + == c_float(value[0][0] / value[0][1]).value + ), "%s didn't roundtrip" % tag + + +class xxxxxxxxxxxxxxxxxxxxx(xxxx.xxxxxxxxxxxxx): + def xxxxxxx_xxxxxx(xxxx): + assert xxxxxxx_xxxx in [ + x.xxxxx.xxxxxx.xxxxx.xxxxxx, + x.xxxxx.xxxxxx.xxxxx.xxxx, + ], ( + "xxxxxxxxxxx xxxxxxx xxxx (xxxxxx xxxx) %x xxx xxxxx" % xxxxxxx_xxxx + ) + + +value.__dict__[key] = ( + "test" # set some Thrift field to non-None in the struct aa bb cc dd ee +) + +RE_ONE_BACKSLASH = { + "asdf_hjkl_jkl": re.compile( + r"(?>\n" +) + +assert ( + str(suffix_arr) + == "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', " + "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', " + "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']" +) +assert ( + str(suffix_arr) + != "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', " + "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', " + "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']" +) +assert ( + str(suffix_arr) + <= "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', " + "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', " + "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']" +) +assert ( + str(suffix_arr) + >= "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', " + "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', " + "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']" +) +assert ( + str(suffix_arr) + < "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', " + "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', " + "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']" +) +assert ( + str(suffix_arr) + > "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', " + "'grykangaroo$', 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', " + "'o$', 'oo$', 'roo$', 'rykangaroo$', 'ykangaroo$']" +) +assert ( + str(suffix_arr) + in "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', 'grykangaroo$'," + " 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', 'o$', 'oo$', 'roo$', 'rykangaroo$'," + " 'ykangaroo$']" +) +assert ( + str(suffix_arr) + not in "['$', 'angaroo$', 'angrykangaroo$', 'aroo$', 'garoo$', 'grykangaroo$'," + " 'kangaroo$', 'ngaroo$', 'ngrykangaroo$', 'o$', 'oo$', 'roo$'," + " 'rykangaroo$', 'ykangaroo$']" +) +message = ( + f"1. Go to Google Developers Console and log in with your Google account." + f"(https://console.developers.google.com/)" + f"2. You should be prompted to create a new project (name does not matter)." + f"3. Click on Enable APIs and Services at the top." + f"4. In the list of APIs choose or search for YouTube Data API v3 and " + f"click on it. Choose Enable." + f"5. Click on Credentials on the left navigation bar." + f"6. Click on Create Credential at the top." + f'7. At the top click the link for "API key".' + f"8. No application restrictions are needed. Click Create at the bottom." + f"9. You now have a key to add to `{{prefix}}set api youtube api_key`" +) +message = ( + f"1. Go to Google Developers Console and log in with your Google account." + f"(https://console.developers.google.com/)" + f"2. You should be prompted to create a new project (name does not matter)." + f"3. Click on Enable APIs and Services at the top." + f"4. In the list of APIs choose or search for YouTube Data API v3 and " + f"click on it. Choose Enable." + f"5. Click on Credentials on the left navigation bar." + f"6. Click on Create Credential at the top." + f'7. At the top click the link for "API key".' + f"8. No application restrictions are needed. Click Create at the bottom." + f"9. You now have a key to add to `{{prefix}}set api youtube api_key`" +) +message = ( + "1. Go to Google Developers Console and log in with your Google account." + "(https://console.developers.google.com/)" + "2. You should be prompted to create a new project (name does not matter)." + "3. Click on Enable APIs and Services at the top." + "4. In the list of APIs choose or search for YouTube Data API v3 and " + "click on it. Choose Enable." + "5. Click on Credentials on the left navigation bar." + "6. Click on Create Credential at the top." + '7. At the top click the link for "API key".' + "8. No application restrictions are needed. Click Create at the bottom." + f"9. You now have a key to add to `{prefix}set api youtube api_key`" +) + +# It shouldn't matter if the string prefixes are capitalized. +temp_msg = ( + f"{F'{humanize_number(pos)}.': <{pound_len+2}} " + f"{balance: <{bal_len + 5}} " + f"<<{author.display_name}>>\n" +) + +fstring = f"We have to remember to escape {braces}. Like {{these}}. But not {this}." + +welcome_to_programming = R"hello," R" world!" + +fstring = ( + f"f-strings definitely make things more {difficult} than they need to be for" + " {black}. But boy they sure are handy. The problem is that some lines will need" + f" to have the 'f' whereas others do not. This {line}, for example, needs one." +) + +x = ( + "This is a long string which contains an f-expr that should not split" + f" {{{[i for i in range(5)]}}}." +) + +x = ( + "\N{BLACK RIGHT-POINTING TRIANGLE WITH DOUBLE VERTICAL BAR}\N{VARIATION SELECTOR-16}" +) + +xxxxxx_xxx_xxxx_xx_xxxxx_xxxxxxxx_xxxxxxxx_xxxxxxxxxx_xxxx_xxxx_xxxxx = xxxx.xxxxxx.xxxxxxxxx.xxxxxxxxxxxxxxxxxxxx( + xx_xxxxxx={ + "x3_xxxxxxxx": ( + "xxx3_xxxxx_xxxxxxxx_xxxxxxxx_xxxxxxxxxx_xxxxxxxx_xxxxxx_xxxxxxx" + ), + }, +) + +# Regression test for https://github.com/psf/black/issues/3117. +some_dict = { + "something_something": ( + r"Lorem ipsum dolor sit amet, an sed convenire eloquentiam \t" + r"signiferumque, duo ea vocibus consetetur scriptorem. Facer \t" + ), +} + +# Regression test for https://github.com/psf/black/issues/3459. +xxxx( + empty_str_as_first_split=( + "" + f"xxxxxxx {xxxxxxxxxx} xxx xxxxxxxxxx xxxxx xxx xxx xx " + "xxxxx xxxxxxxxx xxxxxxx, xxx xxxxxxxxxxx xxx xxxxx. " + f"xxxxxxxxxxxxx xxxx xx xxxxxxxxxx. xxxxx: {x.xxx}" + ), + empty_u_str_as_first_split=( + "" + f"xxxxxxx {xxxxxxxxxx} xxx xxxxxxxxxx xxxxx xxx xxx xx " + "xxxxx xxxxxxxxx xxxxxxx, xxx xxxxxxxxxxx xxx xxxxx. " + f"xxxxxxxxxxxxx xxxx xx xxxxxxxxxx. xxxxx: {x.xxx}" + ), +) + +# Regression test for https://github.com/psf/black/issues/3455. +a_dict = { + "/this/is/a/very/very/very/very/very/very/very/very/very/very/long/key/without/spaces": + # And there is a comment before the value + ("item1", "item2", "item3"), +} + +# Regression test for https://github.com/psf/black/issues/3506. +# Regressed again by https://github.com/psf/black/pull/4498 +s = ( + "With single quote: ' " + f" {my_dict['foo']}" + ' With double quote: " ' + f' {my_dict["bar"]}' +) + +s = ( + "Lorem Ipsum is simply dummy text of the printing and typesetting" + f' industry:\'{my_dict["foo"]}\'' +) + +# Regression test for https://github.com/psf/black/issues/4510. +# Don't merge multi-line strings when a pragma comment follows. +( + "A very very very very very very very very very very very very long string " + "annotated with a type ignore pragma gets merged into a single very long line " + "which is against the line length rule." +) # type: ignore \ No newline at end of file diff --git a/tests/data/cases/preview_prefer_rhs_split_indexed_assignment.py b/tests/data/cases/preview_prefer_rhs_split_indexed_assignment.py new file mode 100644 index 0000000..df8bf45 --- /dev/null +++ b/tests/data/cases/preview_prefer_rhs_split_indexed_assignment.py @@ -0,0 +1,94 @@ +# flags: --preview + +# Indexed assignment with a short RHS expression should not get unnecessary parens. +dictionary_of_arrays["long_key_name_for_the_example"][ + very_long_index_name, index_zero +] = 10 - 5 + +# Unformatted input: the unnecessary parens should be removed. +dictionary_of_arrays["long_key_name_for_the_example"][very_long_index_name, index_zero] = (10 - 5) + +# Longer RHS expressions that fit on the tail line should also lose parens. +dictionary_of_arrays["long_key_name_for_the_example"][very_long_index_name, index_zero] = (1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1) + +# RHS with brackets (function call) should also lose unnecessary parens. +dictionary_of_arrays["long_key_name_for_the_example"][very_long_index_name, index_zero] = (some_function(arg1, arg2)) + +# A long RHS that does not fit on the tail line still gets wrapped in parens. +dictionary_of_arrays["long_key_name_for_the_example"][very_long_index_name, index_zero] = (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) + +# Regression: a ternary RHS with a short target must keep its parentheses +# (no splitting inside the function call). +kwargs["empty_label"] = ( + kwargs.get("empty_label", _("None")) if db_field.blank else None_None_None +) + +# Regression: a method-chain RHS with a short target must keep its parentheses. +two_factor_form["totp_value"] = ( + _get_totp(user.totp_secret).generate(time.time()).decode() +) + +# Regression: parenthesized tuple targets are not indexed assignments. +(self.next,) = ( + self._unpack("Q", self._ensure_read(fp, 8)) + if self._bigtiff + else self._unpack("L", self._ensure_read(fp, 4)) +) + +# Regression: the `]` of an annotation is not a subscripted target. +self.args: list[str] = ( + args[1:] if self.ignore_exit_code or self.invert_exit_code else args_args_args +) + +# output + +# Indexed assignment with a short RHS expression should not get unnecessary parens. +dictionary_of_arrays["long_key_name_for_the_example"][ + very_long_index_name, index_zero +] = 10 - 5 + +# Unformatted input: the unnecessary parens should be removed. +dictionary_of_arrays["long_key_name_for_the_example"][ + very_long_index_name, index_zero +] = 10 - 5 + +# Longer RHS expressions that fit on the tail line should also lose parens. +dictionary_of_arrays["long_key_name_for_the_example"][ + very_long_index_name, index_zero +] = 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + +# RHS with brackets (function call) should also lose unnecessary parens. +dictionary_of_arrays["long_key_name_for_the_example"][ + very_long_index_name, index_zero +] = some_function(arg1, arg2) + +# A long RHS that does not fit on the tail line still gets wrapped in parens. +dictionary_of_arrays["long_key_name_for_the_example"][ + very_long_index_name, index_zero +] = ( + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +) + +# Regression: a ternary RHS with a short target must keep its parentheses +# (no splitting inside the function call). +kwargs["empty_label"] = ( + kwargs.get("empty_label", _("None")) if db_field.blank else None_None_None +) + +# Regression: a method-chain RHS with a short target must keep its parentheses. +two_factor_form["totp_value"] = ( + _get_totp(user.totp_secret).generate(time.time()).decode() +) + +# Regression: parenthesized tuple targets are not indexed assignments. +(self.next,) = ( + self._unpack("Q", self._ensure_read(fp, 8)) + if self._bigtiff + else self._unpack("L", self._ensure_read(fp, 4)) +) + +# Regression: the `]` of an annotation is not a subscripted target. +self.args: list[str] = ( + args[1:] if self.ignore_exit_code or self.invert_exit_code else args_args_args +) diff --git a/tests/data/cases/preview_remove_multiline_lone_list_item_parens.py b/tests/data/cases/preview_remove_multiline_lone_list_item_parens.py new file mode 100644 index 0000000..0856302 --- /dev/null +++ b/tests/data/cases/preview_remove_multiline_lone_list_item_parens.py @@ -0,0 +1,246 @@ +# flags: --unstable +items = [(x for x in [1])] + +items = [ + ( + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} + ) +] +items = [ + ( + {"key1": "val1", "key2": "val2"} + if some_var == "" + else {"key": "val"} + ) +] +items = [ + ( + "123456890123457890123468901234567890" + if some_var == "long strings" + else "123467890123467890" + ) +] +items = [ + ( + {"key1": "val1", "key2": "val2", "key3": "val3"} + and some_var == "long strings" + and {"key": "val"} + ) +] +items = [ + ( + "123456890123457890123468901234567890" + and some_var == "long strings" + and "123467890123467890" + ) +] +items = [ + ( + long_variable_name + and even_longer_variable_name + and yet_another_very_long_variable_name + ) +] + +# Shouldn't remove trailing commas +items = [ + ( + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} + ), +] +items = [ + ( + {"key1": "val1", "key2": "val2", "key3": "val3"} + and some_var == "long strings" + and {"key": "val"} + ), +] +items = [ + ( + "123456890123457890123468901234567890" + and some_var == "long strings" + and "123467890123467890" + ), +] +items = [ + ( + long_variable_name + and even_longer_variable_name + and yet_another_very_long_variable_name + ), +] + +# Shouldn't add parentheses +items = [ + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} +] +items = [{"key1": "val1", "key2": "val2"} if some_var == "" else {"key": "val"}] + +# Shouldn't crash with comments +items = [ + ( # comment + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} + ) +] +items = [ + ( + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} + ) # comment +] + +items = [ # comment + ( + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} + ) +] +items = [ + ( + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} + ) +] # comment + +items = [ + ( + {"key1": "val1", "key2": "val2", "key3": "val3"} # comment + if some_var == "long strings" + else {"key": "val"} + ) +] + +items = [ # comment + ( # comment + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} + ) +] +items = [ + ( + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} + ) # comment +] # comment + + +# output +items = [(x for x in [1])] + +items = [ + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} +] +items = [{"key1": "val1", "key2": "val2"} if some_var == "" else {"key": "val"}] +items = [ + "123456890123457890123468901234567890" + if some_var == "long strings" + else "123467890123467890" +] +items = [ + {"key1": "val1", "key2": "val2", "key3": "val3"} + and some_var == "long strings" + and {"key": "val"} +] +items = [ + "123456890123457890123468901234567890" + and some_var == "long strings" + and "123467890123467890" +] +items = [ + long_variable_name + and even_longer_variable_name + and yet_another_very_long_variable_name +] + +# Shouldn't remove trailing commas +items = [ + ( + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} + ), +] +items = [ + ( + {"key1": "val1", "key2": "val2", "key3": "val3"} + and some_var == "long strings" + and {"key": "val"} + ), +] +items = [ + ( + "123456890123457890123468901234567890" + and some_var == "long strings" + and "123467890123467890" + ), +] +items = [ + ( + long_variable_name + and even_longer_variable_name + and yet_another_very_long_variable_name + ), +] + +# Shouldn't add parentheses +items = [ + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} +] +items = [{"key1": "val1", "key2": "val2"} if some_var == "" else {"key": "val"}] + +# Shouldn't crash with comments +items = [ # comment + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} +] +items = [ + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} +] # comment + +items = [ # comment + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} +] +items = [ + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} +] # comment + +items = [ + {"key1": "val1", "key2": "val2", "key3": "val3"} # comment + if some_var == "long strings" + else {"key": "val"} +] + +items = [ # comment # comment + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} +] +items = [ + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} +] # comment # comment diff --git a/tests/data/cases/preview_return_annotation_brackets_string.py b/tests/data/cases/preview_return_annotation_brackets_string.py new file mode 100644 index 0000000..2f937cf --- /dev/null +++ b/tests/data/cases/preview_return_annotation_brackets_string.py @@ -0,0 +1,24 @@ +# flags: --unstable +# Long string example +def frobnicate() -> "ThisIsTrulyUnreasonablyExtremelyLongClassName | list[ThisIsTrulyUnreasonablyExtremelyLongClassName]": + pass + +# splitting the string breaks if there's any parameters +def frobnicate(a) -> "ThisIsTrulyUnreasonablyExtremelyLongClassName | list[ThisIsTrulyUnreasonablyExtremelyLongClassName]": + pass + +# output + +# Long string example +def frobnicate() -> ( + "ThisIsTrulyUnreasonablyExtremelyLongClassName |" + " list[ThisIsTrulyUnreasonablyExtremelyLongClassName]" +): + pass + + +# splitting the string breaks if there's any parameters +def frobnicate( + a, +) -> "ThisIsTrulyUnreasonablyExtremelyLongClassName | list[ThisIsTrulyUnreasonablyExtremelyLongClassName]": + pass diff --git a/tests/data/cases/preview_simplify_power_operator_hugging.py b/tests/data/cases/preview_simplify_power_operator_hugging.py new file mode 100644 index 0000000..1977396 --- /dev/null +++ b/tests/data/cases/preview_simplify_power_operator_hugging.py @@ -0,0 +1,153 @@ +# flags: --preview +# This is a copy of `power_op_spacing.py`. Remove when `simplify_power_operator_hugging` becomes stable. + +def function(**kwargs): + t = a**2 + b**3 + return t ** 2 + + +def function_replace_spaces(**kwargs): + t = a **2 + b** 3 + c ** 4 + + +def function_dont_replace_spaces(): + {**a, **b, **c} + + +a = 5**~4 +b = 5 ** f() +c = -(5**2) +d = 5 ** f["hi"] +e = lazy(lambda **kwargs: 5) +f = f() ** 5 +g = a.b**c.d +h = 5 ** funcs.f() +i = funcs.f() ** 5 +j = super().name ** 5 +k = [(2**idx, value) for idx, value in pairs] +l = mod.weights_[0] == pytest.approx(0.95**100, abs=0.001) +m = [([2**63], [1, 2**63])] +n = count <= 10**5 +o = settings(max_examples=10**6) +p = {(k, k**2): v**2 for k, v in pairs} +q = [10**i for i in range(6)] +r = x**y +s = 1 ** 1 +t = ( + 1 + ** 1 + **1 + ** 1 +) + +a = 5.0**~4.0 +b = 5.0 ** f() +c = -(5.0**2.0) +d = 5.0 ** f["hi"] +e = lazy(lambda **kwargs: 5) +f = f() ** 5.0 +g = a.b**c.d +h = 5.0 ** funcs.f() +i = funcs.f() ** 5.0 +j = super().name ** 5.0 +k = [(2.0**idx, value) for idx, value in pairs] +l = mod.weights_[0] == pytest.approx(0.95**100, abs=0.001) +m = [([2.0**63.0], [1.0, 2**63.0])] +n = count <= 10**5.0 +o = settings(max_examples=10**6.0) +p = {(k, k**2): v**2.0 for k, v in pairs} +q = [10.5**i for i in range(6)] +s = 1.0 ** 1.0 +t = ( + 1.0 + ** 1.0 + **1.0 + ** 1.0 +) + + +# WE SHOULD DEFINITELY NOT EAT THESE COMMENTS (https://github.com/psf/black/issues/2873) +if hasattr(view, "sum_of_weights"): + return np.divide( # type: ignore[no-any-return] + view.variance, # type: ignore[union-attr] + view.sum_of_weights, # type: ignore[union-attr] + out=np.full(view.sum_of_weights.shape, np.nan), # type: ignore[union-attr] + where=view.sum_of_weights**2 > view.sum_of_weights_squared, # type: ignore[union-attr] + ) + +return np.divide( + where=view.sum_of_weights_of_weight_long**2 > view.sum_of_weights_squared, # type: ignore +) + + +# output +# This is a copy of `power_op_spacing.py`. Remove when `simplify_power_operator_hugging` becomes stable. + + +def function(**kwargs): + t = a**2 + b**3 + return t**2 + + +def function_replace_spaces(**kwargs): + t = a**2 + b**3 + c**4 + + +def function_dont_replace_spaces(): + {**a, **b, **c} + + +a = 5**~4 +b = 5 ** f() +c = -(5**2) +d = 5 ** f["hi"] +e = lazy(lambda **kwargs: 5) +f = f() ** 5 +g = a.b**c.d +h = 5 ** funcs.f() +i = funcs.f() ** 5 +j = super().name ** 5 +k = [(2**idx, value) for idx, value in pairs] +l = mod.weights_[0] == pytest.approx(0.95**100, abs=0.001) +m = [([2**63], [1, 2**63])] +n = count <= 10**5 +o = settings(max_examples=10**6) +p = {(k, k**2): v**2 for k, v in pairs} +q = [10**i for i in range(6)] +r = x**y +s = 1**1 +t = 1**1**1**1 + +a = 5.0**~4.0 +b = 5.0 ** f() +c = -(5.0**2.0) +d = 5.0 ** f["hi"] +e = lazy(lambda **kwargs: 5) +f = f() ** 5.0 +g = a.b**c.d +h = 5.0 ** funcs.f() +i = funcs.f() ** 5.0 +j = super().name ** 5.0 +k = [(2.0**idx, value) for idx, value in pairs] +l = mod.weights_[0] == pytest.approx(0.95**100, abs=0.001) +m = [([2.0**63.0], [1.0, 2**63.0])] +n = count <= 10**5.0 +o = settings(max_examples=10**6.0) +p = {(k, k**2): v**2.0 for k, v in pairs} +q = [10.5**i for i in range(6)] +s = 1.0**1.0 +t = 1.0**1.0**1.0**1.0 + + +# WE SHOULD DEFINITELY NOT EAT THESE COMMENTS (https://github.com/psf/black/issues/2873) +if hasattr(view, "sum_of_weights"): + return np.divide( # type: ignore[no-any-return] + view.variance, # type: ignore[union-attr] + view.sum_of_weights, # type: ignore[union-attr] + out=np.full(view.sum_of_weights.shape, np.nan), # type: ignore[union-attr] + where=view.sum_of_weights**2 > view.sum_of_weights_squared, # type: ignore[union-attr] + ) + +return np.divide( + where=view.sum_of_weights_of_weight_long**2 > view.sum_of_weights_squared, # type: ignore +) diff --git a/tests/data/cases/preview_simplify_power_operator_hugging_long.py b/tests/data/cases/preview_simplify_power_operator_hugging_long.py new file mode 100644 index 0000000..1ec7acd --- /dev/null +++ b/tests/data/cases/preview_simplify_power_operator_hugging_long.py @@ -0,0 +1,99 @@ +# flags: --preview +# This is a copy of `power_op_spacing_long.py` with output adjusted for `simplify_power_operator_hugging`. +a = 1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1 +b = 1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1 +c = 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 +d = 1**1 ** 1**1 ** 1**1 ** 1**1 ** 1**1**1 ** 1 ** 1**1 ** 1**1**1**1**1 ** 1 ** 1**1**1 **1**1** 1 ** 1 ** 1 +e = 𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟 +f = 𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟 + +a = 1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0 +b = 1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0 +c = 1.0 ** 1.0 ** 1.0 ** 1.0 ** 1.0 ** 1.0 ** 1.0 ** 1.0 ** 1.0 ** 1.0 ** 1.0 ** 1.0 ** 1.0 ** 1.0 ** 1.0 ** 1.0 ** 1.0 +d = 1.0**1.0 ** 1.0**1.0 ** 1.0**1.0 ** 1.0**1.0 ** 1.0**1.0**1.0 ** 1.0 ** 1.0**1.0 ** 1.0**1.0**1.0 + +# output +# This is a copy of `power_op_spacing_long.py` with output adjusted for `simplify_power_operator_hugging`. +a = 1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1 +b = ( + 1 + **1 + **1 + **1 + **1 + **1 + **1 + **1 + **1 + **1 + **1 + **1 + **1 + **1 + **1 + **1 + **1 + **1 + **1 + **1 + **1 + **1 + **1 + **1 + **1 + **1 + **1 + **1 + **1 +) +c = 1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1 +d = 1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1 +e = 𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟**𨉟 +f = ( + 𨉟 + **𨉟 + **𨉟 + **𨉟 + **𨉟 + **𨉟 + **𨉟 + **𨉟 + **𨉟 + **𨉟 + **𨉟 + **𨉟 + **𨉟 + **𨉟 + **𨉟 + **𨉟 + **𨉟 + **𨉟 + **𨉟 + **𨉟 + **𨉟 + **𨉟 +) + +a = 1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0 +b = ( + 1.0 + **1.0 + **1.0 + **1.0 + **1.0 + **1.0 + **1.0 + **1.0 + **1.0 + **1.0 + **1.0 + **1.0 + **1.0 + **1.0 + **1.0 + **1.0 + **1.0 + **1.0 +) +c = 1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0 +d = 1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0**1.0 diff --git a/tests/data/cases/preview_wrap_comprehension_in.py b/tests/data/cases/preview_wrap_comprehension_in.py new file mode 100644 index 0000000..4e526d5 --- /dev/null +++ b/tests/data/cases/preview_wrap_comprehension_in.py @@ -0,0 +1,171 @@ +# flags: --preview --line-length=79 + +[a for graph_path_expression in refined_constraint.condition_as_predicate.variables] +[ + a + for graph_path_expression in refined_constraint.condition_as_predicate.variables +] +[ + a + for graph_path_expression + in refined_constraint.condition_as_predicate.variables +] +[ + a + for graph_path_expression in ( + refined_constraint.condition_as_predicate.variables + ) +] + +[ + (foobar_very_long_key, foobar_very_long_value) + for foobar_very_long_key, foobar_very_long_value in foobar_very_long_dictionary.items() +] + +# Don't split the `in` if it's not too long +lcomp3 = [ + element.split("\n", 1)[0] + for element in collection.select_elements() + # right + if element is not None +] + +# Don't remove parens around ternaries +expected = [i for i in (a if b else c)] + +# Don't remove parens around lambdas; without them the trailing comprehension +# clauses would be parsed as part of the lambda body, producing invalid code +lambda_iter = [i for i in (lambda: 0) if i] +lambda_iter_no_clause = [i for i in (lambda x: x)] + +# Nested arrays +# First in will not be split because it would still be too long +[[ + x + for x in bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb + for y in xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +]] + +# Multiple comprehensions, only split the second `in` +graph_path_expressions_in_local_constraint_refinements = [ + graph_path_expression + for refined_constraint in self._local_constraint_refinements.values() + if refined_constraint is not None + for graph_path_expression in refined_constraint.condition_as_predicate.variables +] + +# Dictionary comprehensions +dict_with_really_long_names = { + really_really_long_key_name: an_even_longer_really_really_long_key_value + for really_really_long_key_name, an_even_longer_really_really_long_key_value in really_really_really_long_dict_name.items() +} +{ + key_with_super_really_long_name: key_with_super_really_long_name + for key_with_super_really_long_name in dictionary_with_super_really_long_name +} +{ + key_with_super_really_long_name: key_with_super_really_long_name + for key_with_super_really_long_name + in dictionary_with_super_really_long_name +} +{ + key_with_super_really_long_name: key_with_super_really_long_name + for key in ( + dictionary + ) +} + +# output +[ + a + for graph_path_expression in ( + refined_constraint.condition_as_predicate.variables + ) +] +[ + a + for graph_path_expression in ( + refined_constraint.condition_as_predicate.variables + ) +] +[ + a + for graph_path_expression in ( + refined_constraint.condition_as_predicate.variables + ) +] +[ + a + for graph_path_expression in ( + refined_constraint.condition_as_predicate.variables + ) +] + +[ + (foobar_very_long_key, foobar_very_long_value) + for foobar_very_long_key, foobar_very_long_value in ( + foobar_very_long_dictionary.items() + ) +] + +# Don't split the `in` if it's not too long +lcomp3 = [ + element.split("\n", 1)[0] + for element in collection.select_elements() + # right + if element is not None +] + +# Don't remove parens around ternaries +expected = [i for i in (a if b else c)] + +# Don't remove parens around lambdas; without them the trailing comprehension +# clauses would be parsed as part of the lambda body, producing invalid code +lambda_iter = [i for i in (lambda: 0) if i] +lambda_iter_no_clause = [i for i in (lambda x: x)] + +# Nested arrays +# First in will not be split because it would still be too long +[ + [ + x + for x in bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb + for y in ( + xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx + ) + ] +] + +# Multiple comprehensions, only split the second `in` +graph_path_expressions_in_local_constraint_refinements = [ + graph_path_expression + for refined_constraint in self._local_constraint_refinements.values() + if refined_constraint is not None + for graph_path_expression in ( + refined_constraint.condition_as_predicate.variables + ) +] + +# Dictionary comprehensions +dict_with_really_long_names = { + really_really_long_key_name: an_even_longer_really_really_long_key_value + for really_really_long_key_name, an_even_longer_really_really_long_key_value in ( + really_really_really_long_dict_name.items() + ) +} +{ + key_with_super_really_long_name: key_with_super_really_long_name + for key_with_super_really_long_name in ( + dictionary_with_super_really_long_name + ) +} +{ + key_with_super_really_long_name: key_with_super_really_long_name + for key_with_super_really_long_name in ( + dictionary_with_super_really_long_name + ) +} +{ + key_with_super_really_long_name: key_with_super_really_long_name + for key in dictionary +} diff --git a/tests/data/cases/py310_pep572.py b/tests/data/cases/py310_pep572.py new file mode 100644 index 0000000..73fbe44 --- /dev/null +++ b/tests/data/cases/py310_pep572.py @@ -0,0 +1,13 @@ +# flags: --minimum-version=3.10 +x[a:=0] +x[a := 0] +x[a := 0, b := 1] +x[5, b := 0] +x[a:=0,b:=1] + +# output +x[a := 0] +x[a := 0] +x[a := 0, b := 1] +x[5, b := 0] +x[a := 0, b := 1] diff --git a/tests/data/cases/pyi_decorated_class_blank_line.py b/tests/data/cases/pyi_decorated_class_blank_line.py new file mode 100644 index 0000000..c66f50a --- /dev/null +++ b/tests/data/cases/pyi_decorated_class_blank_line.py @@ -0,0 +1,115 @@ +# flags: --preview --pyi +# +# Test case for https://github.com/psf/black/issues/4256 +# Blank line should be enforced between a function and a decorated class in stubs. + +def foo(): ... +@decorator +class Bar: ... + +def baz(): ... + +@decorator +class Qux: ... + +class Already: ... + +@decorator +class After: ... + +@decorator +class First: ... +@decorator +class Second: ... + +def before(): ... +@decorator1 +@decorator2 +class MultiDecorated: ... + +@decorator +def decorated_func(): ... +@decorator +class AfterDecoratedFunc: ... + +class Outer: + def method(self) -> None: ... + @decorator + class Inner: ... + + @decorator + class AnotherInner: ... + def after_inner(self) -> None: ... + + @decorator + class InnerA: ... + @decorator + class InnerB: ... + +def func(): ... +@decorator +class NonStub: + x: int + y: str + +# output +# +# Test case for https://github.com/psf/black/issues/4256 +# Blank line should be enforced between a function and a decorated class in stubs. + +def foo(): ... + +@decorator +class Bar: ... + +def baz(): ... + +@decorator +class Qux: ... + +class Already: ... + +@decorator +class After: ... + +@decorator +class First: ... + +@decorator +class Second: ... + +def before(): ... + +@decorator1 +@decorator2 +class MultiDecorated: ... + +@decorator +def decorated_func(): ... + +@decorator +class AfterDecoratedFunc: ... + +class Outer: + def method(self) -> None: ... + + @decorator + class Inner: ... + + @decorator + class AnotherInner: ... + + def after_inner(self) -> None: ... + + @decorator + class InnerA: ... + + @decorator + class InnerB: ... + +def func(): ... + +@decorator +class NonStub: + x: int + y: str diff --git a/tests/data/cases/pyi_docstring_blank_lines.py b/tests/data/cases/pyi_docstring_blank_lines.py new file mode 100644 index 0000000..88ddf3d --- /dev/null +++ b/tests/data/cases/pyi_docstring_blank_lines.py @@ -0,0 +1,164 @@ +# flags: --preview --pyi +import sys +from typing import overload + +def top_level_comment() -> None: + """docs""" +# leading comment for the next statement +top_level_attr: int + +def top_level_if() -> None: + """docs""" +if sys.version_info >= (3, 12): + top_level_if_attr: int + +class C: + def before_comment(self) -> None: + """docs""" + # leading comment for the next method + def after_comment(self) -> None: ... + + def before_if(self) -> None: + """docs""" + if sys.version_info >= (3, 12): + if_attr: int + + if sys.version_info >= (3, 12): + def conditional_before_attr(self) -> None: + """docs""" + conditional_attr: int + + def before_attr(self) -> None: + """docs""" + attr: int + + @decorator + def before_decorator(self) -> None: + """docs""" + @decorator + def after_decorator(self) -> None: ... + + @decorator + def decorated_before_comment(self) -> None: + """docs""" + # leading comment for the next attribute + decorated_attr: int + + @overload + def overloaded(self, value: int) -> int: + """Int overload.""" + @overload + def overloaded(self, value: str) -> str: ... + + @overload + def overloaded_with_comment(self, value: int) -> int: + """Int overload.""" + # comment inside the overload group + @overload + def overloaded_with_comment(self, value: str) -> str: ... + + @overload + def overloaded_with_commented_if(self, value: int) -> int: + """Int overload.""" + # comment inside the conditional overload group + if sys.version_info >= (3, 12): + @overload + def overloaded_with_commented_if(self, value: str) -> str: ... + + @property + def prop(self) -> int: + """Property docs.""" + @prop.setter + def prop(self, value: int) -> None: ... + +class EndsWithDecoratedDocstringAndComment: + @decorator + def method(self) -> None: + """docs""" + # trailing member comment + +# output +import sys +from typing import overload + +def top_level_comment() -> None: + """docs""" + +# leading comment for the next statement +top_level_attr: int + +def top_level_if() -> None: + """docs""" + +if sys.version_info >= (3, 12): + top_level_if_attr: int + +class C: + def before_comment(self) -> None: + """docs""" + + # leading comment for the next method + def after_comment(self) -> None: ... + def before_if(self) -> None: + """docs""" + + if sys.version_info >= (3, 12): + if_attr: int + + if sys.version_info >= (3, 12): + def conditional_before_attr(self) -> None: + """docs""" + + conditional_attr: int + + def before_attr(self) -> None: + """docs""" + + attr: int + + @decorator + def before_decorator(self) -> None: + """docs""" + + @decorator + def after_decorator(self) -> None: ... + @decorator + def decorated_before_comment(self) -> None: + """docs""" + + # leading comment for the next attribute + decorated_attr: int + + @overload + def overloaded(self, value: int) -> int: + """Int overload.""" + @overload + def overloaded(self, value: str) -> str: ... + + @overload + def overloaded_with_comment(self, value: int) -> int: + """Int overload.""" + # comment inside the overload group + @overload + def overloaded_with_comment(self, value: str) -> str: ... + + @overload + def overloaded_with_commented_if(self, value: int) -> int: + """Int overload.""" + # comment inside the conditional overload group + if sys.version_info >= (3, 12): + @overload + def overloaded_with_commented_if(self, value: str) -> str: ... + + @property + def prop(self) -> int: + """Property docs.""" + @prop.setter + def prop(self, value: int) -> None: ... + +class EndsWithDecoratedDocstringAndComment: + @decorator + def method(self) -> None: + """docs""" + + # trailing member comment diff --git a/tests/data/cases/pyi_docstring_blank_lines_no_preview.py b/tests/data/cases/pyi_docstring_blank_lines_no_preview.py new file mode 100644 index 0000000..56364cd --- /dev/null +++ b/tests/data/cases/pyi_docstring_blank_lines_no_preview.py @@ -0,0 +1,12 @@ +# flags: --pyi +import sys + +class C: + def before_comment(self) -> None: + """docs""" + # leading comment for the next method + def after_comment(self) -> None: ... + def before_if(self) -> None: + """docs""" + if sys.version_info >= (3, 12): + if_attr: int diff --git a/tests/data/cases/pyi_overload_groups.py b/tests/data/cases/pyi_overload_groups.py new file mode 100644 index 0000000..71eb3fb --- /dev/null +++ b/tests/data/cases/pyi_overload_groups.py @@ -0,0 +1,945 @@ +# flags: --preview --pyi +# +# Test cases for blank line handling around overload groups in .pyi files: +# - No blank lines between consecutive same-name decorated functions (overloads) +# - No blank lines between overloads even when a function has a docstring +# - Blank line enforced after an overload group before an unrelated statement +# - Blank line enforced before an overload group after an unrelated statement +# - Blank lines between differently-named decorated functions +# - Async overloaded functions +# - Class-level overload groups with various transitions +# - Transition from undecorated def to decorated overload group +# - Overload group immediately followed by undecorated function (no blank line) +# - Overload groups adjacent to if sys.version_info blocks +# - Overload groups inside if blocks adjacent to undecorated functions +# - Conditional overloads (if/else) with docstrings preceded/followed by undecorated defs +# - Undecorated function around @property-decorated function (with and without gaps) +# - Decorated class with undecorated methods (no spurious blank lines) +import sys +from typing import overload, type_check_only + +def decorator(func): ... + +@overload +def a(x: int) -> int: ... +@overload +def a(x: str) -> str: ... +def b(x): ... +@decorator +def c() -> None: ... +@overload +def d(x: int) -> int: + """Int overload.""" +@overload +def d(x: str) -> str: ... +def e(x): ... + +@overload +async def async_a(x: int) -> int: ... +@overload +async def async_a(x: str) -> str: ... +var: int + +class MyClass: + @overload + def method(self, x: int) -> int: ... + @overload + def method(self, x: str) -> str: ... + def after_method(self, x): ... + + @overload + def with_docs(self, x: int) -> int: + """Int.""" + @overload + def with_docs(self, x: str) -> str: ... + def after_with_docs(self, x): ... + + @overload + def no_gap(self, x: int) -> int: ... + @overload + def no_gap(self, x: str) -> str: ... + @decorator + def different_method(self) -> None: ... + + @decorator + def another_dec(self) -> None: ... + @decorator + def yet_another_dec(self) -> None: ... + + attr: int + @overload + def after_attr(self, x: int) -> int: ... + @overload + def after_attr(self, x: str) -> str: ... + attr2: str + + @property + def prop1(self) -> int: ... + @property + def prop2(self) -> str: ... + @property + def prop3(self) -> bytes: ... + @property + def prop4_with_setter(self) -> int: ... + @prop4_with_setter.setter + def prop4_with_setter(self, value: int) -> None: ... + @property + def prop_5_with_setter(self) -> int: ... + @prop_5_with_setter.setter + def prop_5_with_setter(self, value: int) -> None: ... + @property + def prop6(self) -> int: ... + @property + def prop7(self) -> str: ... + @property + def prop8_with_setter(self) -> int: ... + @prop8_with_setter.setter + def prop8_with_setter(self, value: int) -> None: ... + @property + def prop9(self) -> int: ... + @property + def prop10_with_docstring(self) -> int: + """Prop with docstring.""" + @property + def prop11_with_docstring(self) -> int: + """Another prop with docstring.""" + @property + def prop12(self) -> int: ... + + @classmethod + def make_myclass(cls) -> "MyClass": ... + + @staticmethod + def static_method() -> None: ... + + +def plain() -> None: ... +@overload +def different(x: int) -> int: ... +@overload +def different(x: str) -> str: ... + +def another_plain() -> None: ... +@decorator +def alpha() -> None: ... +@decorator +def beta() -> None: ... + +@overload +def multi(x: int) -> int: + """Int version.""" +@overload +def multi(x: str) -> str: + """Str version.""" +@overload +def multi(x: bytes) -> bytes: ... + +def next_func() -> None: ... + +@overload +def three_overloads(x: int) -> int: ... +@overload +def three_overloads(x: str) -> str: ... +@overload +def three_overloads(x: bytes) -> bytes: ... + +@overload +def four_overloads(x: int) -> int: ... +@overload +def four_overloads(x: str) -> str: ... + +@overload +def four_overloads(x: bytes) -> bytes: ... +@overload +def four_overloads(x: float) -> float: ... + +@overload +def before_if_no_gap(x: int) -> int: ... +@overload +def before_if_no_gap(x: str) -> str: ... +if sys.version_info >= (3, 10): + def conditional_func() -> None: ... + +if sys.version_info >= (3, 10): + def other_conditional() -> None: ... +@overload +def after_if_no_gap(x: int) -> int: ... +@overload +def after_if_no_gap(x: str) -> str: ... + +@overload +def before_if_with_gap(x: int) -> int: ... +@overload +def before_if_with_gap(x: str) -> str: ... + +if sys.version_info >= (3, 10): + def conditional_func2() -> None: ... + +if sys.version_info >= (3, 10): + def other_conditional2() -> None: ... + +@overload +def after_if_with_gap(x: int) -> int: ... +@overload +def after_if_with_gap(x: str) -> str: ... + +if sys.version_info >= (3, 10): + @overload + def nested_overload_before(x: int) -> int: ... + @overload + def nested_overload_before(x: str) -> str: ... + def undecorated_after() -> None: ... + +if sys.version_info >= (3, 10): + def undecorated_before() -> None: ... + @overload + def nested_overload_after(x: int) -> int: ... + @overload + def nested_overload_after(x: str) -> str: ... + +if sys.version_info >= (3, 10): + @overload + def nested_overload_before_with_gap(x: int) -> int: ... + @overload + def nested_overload_before_with_gap(x: str) -> str: ... + + def undecorated_after_with_gap() -> None: ... + +if sys.version_info >= (3, 10): + def undecorated_before_with_gap() -> None: ... + + @overload + def nested_overload_after_with_gap(x: int) -> int: ... + @overload + def nested_overload_after_with_gap(x: str) -> str: ... + +def before_conditional_overload() -> None: ... +if sys.version_info >= (3, 10): + @overload + def conditional_overload(x: int) -> int: + """Int.""" +else: + @overload + def conditional_overload(x: int) -> int: + """Int old.""" +@overload +def conditional_overload(x: str) -> str: ... +def after_conditional_overload() -> None: ... + +def before_conditional_overload_with_gaps() -> None: ... + +if sys.version_info >= (3, 10): + @overload + def conditional_overload_with_gaps(x: int) -> int: + """Int.""" +else: + @overload + def conditional_overload_with_gaps(x: int) -> int: + """Int old.""" + +@overload +def conditional_overload_with_gaps(x: str) -> str: ... + +def after_conditional_overload_with_gaps() -> None: ... + +if sys.version_info >= (3, 10): + @overload + def if_else_different_names(x: int) -> int: ... + @overload + def if_else_different_names(x: str) -> str: ... +else: + @overload + def if_else_other_name(x: int) -> int: ... + @overload + def if_else_other_name(x: str) -> str: ... + +@overload +def commented(x: int) -> int: ... +# comment in overload group +@overload +def commented(x: str) -> str: ... +def after_commented() -> None: ... + +class MyClassWithComments: + @overload + def commented_method(self, x: int) -> int: ... + # comment between class overloads + @overload + def commented_method(self, x: str) -> str: ... + def after_commented_method(self) -> None: ... + + @overload + def three_overload_methods(self, x: int) -> int: ... + + # comment after first with gap above that is retained + @overload + def three_overload_methods(self, x: str) -> str: ... + # comment after second with gap below that is removed + + @overload + def three_overload_methods(self, x: bytes) -> bytes: ... + def after_three_overloads(self) -> None: ... + + @overload + def four_overload_methods(self, x: int) -> int: ... + + # comment after first with gaps on both lines + + @overload + def four_overload_methods(self, x: str) -> str: ... + + + # comment after second with too many gaps above + @overload + def four_overload_methods(self, x: bytes) -> bytes: ... + + + # comment after third with large gaps below and above + + + @overload + def four_overload_methods(self, x: list[bytes]) -> bytes: ... + +@overload +def commented_gap_above(x: int) -> int: ... + +# comment with gap above that is retained +@overload +def commented_gap_above(x: str) -> str: ... + +@overload +def commented_gap_below(x: int) -> int: ... +# comment with gap below that is removed + +@overload +def commented_gap_below(x: str) -> str: ... + +@overload +def commented_gaps_both(x: int) -> int: ... + +# comment with gaps on both sides + +@overload +def commented_gaps_both(x: str) -> str: ... + +@overload +def multi_comment(x: int) -> int: ... +# first comment +# second comment +@overload +def multi_comment(x: str) -> str: ... + +@overload +def large_comment_gaps(x: int) -> int: ... + + +# comment with large gaps above that are collapsed +@overload +def large_comment_gaps(x: str) -> str: ... + + +# comment with large gaps above and below that are collapsed + + +@overload +def large_comment_gaps(x: int) -> int: ... + +@overload +def conditional_commented(x: int) -> int: ... + + +# comment + +if sys.version_info >= (3, 10): + + # comment + @overload + def conditional_commented(x: str) -> str: ... +else: + + # comment + @overload + def conditional_commented(x: str) -> str: ... + +def before_comment_group() -> None: ... +# comment before overload group +@overload +def comment_before(x: int) -> int: ... +@overload +def comment_before(x: str) -> str: ... +def after_comment_group() -> None: ... + +class ClassWithConditionalOverloads: + def method(self) -> None: ... + if sys.version_info >= (3, 10): + @overload + def conditional(self, x: int) -> int: ... + else: + @overload + def conditional(self, x: str) -> str: ... + @overload + def conditional(self, x: bytes) -> bytes: ... + + @overload + def conditional_commented(self, x: int) -> int: ... + + # comment + + if sys.version_info >= (3, 10): + + # comment + + @overload + def conditional_commented(self, x: str) -> str: ... + else: + + # comment + + @overload + def conditional_commented(self, x: str) -> str: ... + +class ClassWithOverloadThenConditional: + @overload + def method(self, x: int) -> int: ... + @overload + def method(self, x: str) -> str: ... + if sys.version_info >= (3, 10): + @overload + def method(self, x: bytes) -> bytes: ... + +class ClassWithNonOverloadConditional: + def regular(self) -> None: ... + if sys.version_info < (3, 12): + @staticmethod + def legacy_method() -> str: + """Deprecated.""" + +@type_check_only +class DecoratedClassWithUndecoratedMethods: + def method_a(self) -> None: ... + def method_b(self) -> None: ... + def method_c(self) -> None: ... + +if sys.version_info >= (3, 12): + @overload + def elif_overload(x: int) -> int: ... +elif sys.version_info >= (3, 10): + @overload + def elif_overload(x: float) -> float: ... +else: + @overload + def elif_overload(x: bytes) -> bytes: ... +@overload +def elif_overload(x: str) -> str: ... + +@overload +def before_class(x: int) -> int: ... +@overload +def before_class(x: str) -> str: ... +class AfterOverloadGroup: ... + +class AfterOverloadGroup2: ... +@overload +def after_class(x: int) -> int: ... +@overload +def after_class(x: str) -> str: ... + +@overload +@decorator +def multi_decorated(x: int) -> int: ... +@overload +@decorator +def multi_decorated(x: str) -> str: ... +def after_multi_decorated() -> None: ... + +class Outer: + class Inner: + @overload + def method(self, x: int) -> int: ... + @overload + def method(self, x: str) -> str: ... + @overload + def method(self, x: int) -> int: ... + @overload + def method(self, x: str) -> str: ... + + +# output +# +# Test cases for blank line handling around overload groups in .pyi files: +# - No blank lines between consecutive same-name decorated functions (overloads) +# - No blank lines between overloads even when a function has a docstring +# - Blank line enforced after an overload group before an unrelated statement +# - Blank line enforced before an overload group after an unrelated statement +# - Blank lines between differently-named decorated functions +# - Async overloaded functions +# - Class-level overload groups with various transitions +# - Transition from undecorated def to decorated overload group +# - Overload group immediately followed by undecorated function (no blank line) +# - Overload groups adjacent to if sys.version_info blocks +# - Overload groups inside if blocks adjacent to undecorated functions +# - Conditional overloads (if/else) with docstrings preceded/followed by undecorated defs +# - Undecorated function around @property-decorated function (with and without gaps) +# - Decorated class with undecorated methods (no spurious blank lines) +import sys +from typing import overload, type_check_only + +def decorator(func): ... + +@overload +def a(x: int) -> int: ... +@overload +def a(x: str) -> str: ... + +def b(x): ... +@decorator +def c() -> None: ... + +@overload +def d(x: int) -> int: + """Int overload.""" +@overload +def d(x: str) -> str: ... + +def e(x): ... + +@overload +async def async_a(x: int) -> int: ... +@overload +async def async_a(x: str) -> str: ... + +var: int + +class MyClass: + @overload + def method(self, x: int) -> int: ... + @overload + def method(self, x: str) -> str: ... + + def after_method(self, x): ... + + @overload + def with_docs(self, x: int) -> int: + """Int.""" + @overload + def with_docs(self, x: str) -> str: ... + + def after_with_docs(self, x): ... + + @overload + def no_gap(self, x: int) -> int: ... + @overload + def no_gap(self, x: str) -> str: ... + + @decorator + def different_method(self) -> None: ... + @decorator + def another_dec(self) -> None: ... + @decorator + def yet_another_dec(self) -> None: ... + + attr: int + + @overload + def after_attr(self, x: int) -> int: ... + @overload + def after_attr(self, x: str) -> str: ... + + attr2: str + + @property + def prop1(self) -> int: ... + @property + def prop2(self) -> str: ... + @property + def prop3(self) -> bytes: ... + + @property + def prop4_with_setter(self) -> int: ... + @prop4_with_setter.setter + def prop4_with_setter(self, value: int) -> None: ... + + @property + def prop_5_with_setter(self) -> int: ... + @prop_5_with_setter.setter + def prop_5_with_setter(self, value: int) -> None: ... + + @property + def prop6(self) -> int: ... + @property + def prop7(self) -> str: ... + + @property + def prop8_with_setter(self) -> int: ... + @prop8_with_setter.setter + def prop8_with_setter(self, value: int) -> None: ... + + @property + def prop9(self) -> int: ... + @property + def prop10_with_docstring(self) -> int: + """Prop with docstring.""" + + @property + def prop11_with_docstring(self) -> int: + """Another prop with docstring.""" + + @property + def prop12(self) -> int: ... + @classmethod + def make_myclass(cls) -> "MyClass": ... + @staticmethod + def static_method() -> None: ... + +def plain() -> None: ... + +@overload +def different(x: int) -> int: ... +@overload +def different(x: str) -> str: ... + +def another_plain() -> None: ... +@decorator +def alpha() -> None: ... +@decorator +def beta() -> None: ... + +@overload +def multi(x: int) -> int: + """Int version.""" +@overload +def multi(x: str) -> str: + """Str version.""" +@overload +def multi(x: bytes) -> bytes: ... + +def next_func() -> None: ... + +@overload +def three_overloads(x: int) -> int: ... +@overload +def three_overloads(x: str) -> str: ... +@overload +def three_overloads(x: bytes) -> bytes: ... + +@overload +def four_overloads(x: int) -> int: ... +@overload +def four_overloads(x: str) -> str: ... +@overload +def four_overloads(x: bytes) -> bytes: ... +@overload +def four_overloads(x: float) -> float: ... + +@overload +def before_if_no_gap(x: int) -> int: ... +@overload +def before_if_no_gap(x: str) -> str: ... + +if sys.version_info >= (3, 10): + def conditional_func() -> None: ... + +if sys.version_info >= (3, 10): + def other_conditional() -> None: ... + +@overload +def after_if_no_gap(x: int) -> int: ... +@overload +def after_if_no_gap(x: str) -> str: ... + +@overload +def before_if_with_gap(x: int) -> int: ... +@overload +def before_if_with_gap(x: str) -> str: ... + +if sys.version_info >= (3, 10): + def conditional_func2() -> None: ... + +if sys.version_info >= (3, 10): + def other_conditional2() -> None: ... + +@overload +def after_if_with_gap(x: int) -> int: ... +@overload +def after_if_with_gap(x: str) -> str: ... + +if sys.version_info >= (3, 10): + @overload + def nested_overload_before(x: int) -> int: ... + @overload + def nested_overload_before(x: str) -> str: ... + + def undecorated_after() -> None: ... + +if sys.version_info >= (3, 10): + def undecorated_before() -> None: ... + + @overload + def nested_overload_after(x: int) -> int: ... + @overload + def nested_overload_after(x: str) -> str: ... + +if sys.version_info >= (3, 10): + @overload + def nested_overload_before_with_gap(x: int) -> int: ... + @overload + def nested_overload_before_with_gap(x: str) -> str: ... + + def undecorated_after_with_gap() -> None: ... + +if sys.version_info >= (3, 10): + def undecorated_before_with_gap() -> None: ... + + @overload + def nested_overload_after_with_gap(x: int) -> int: ... + @overload + def nested_overload_after_with_gap(x: str) -> str: ... + +def before_conditional_overload() -> None: ... + +if sys.version_info >= (3, 10): + @overload + def conditional_overload(x: int) -> int: + """Int.""" +else: + @overload + def conditional_overload(x: int) -> int: + """Int old.""" + +@overload +def conditional_overload(x: str) -> str: ... + +def after_conditional_overload() -> None: ... +def before_conditional_overload_with_gaps() -> None: ... + +if sys.version_info >= (3, 10): + @overload + def conditional_overload_with_gaps(x: int) -> int: + """Int.""" +else: + @overload + def conditional_overload_with_gaps(x: int) -> int: + """Int old.""" + +@overload +def conditional_overload_with_gaps(x: str) -> str: ... + +def after_conditional_overload_with_gaps() -> None: ... + +if sys.version_info >= (3, 10): + @overload + def if_else_different_names(x: int) -> int: ... + @overload + def if_else_different_names(x: str) -> str: ... + +else: + @overload + def if_else_other_name(x: int) -> int: ... + @overload + def if_else_other_name(x: str) -> str: ... + +@overload +def commented(x: int) -> int: ... +# comment in overload group +@overload +def commented(x: str) -> str: ... + +def after_commented() -> None: ... + +class MyClassWithComments: + @overload + def commented_method(self, x: int) -> int: ... + # comment between class overloads + @overload + def commented_method(self, x: str) -> str: ... + + def after_commented_method(self) -> None: ... + + @overload + def three_overload_methods(self, x: int) -> int: ... + + # comment after first with gap above that is retained + @overload + def three_overload_methods(self, x: str) -> str: ... + # comment after second with gap below that is removed + @overload + def three_overload_methods(self, x: bytes) -> bytes: ... + + def after_three_overloads(self) -> None: ... + + @overload + def four_overload_methods(self, x: int) -> int: ... + + # comment after first with gaps on both lines + @overload + def four_overload_methods(self, x: str) -> str: ... + + # comment after second with too many gaps above + @overload + def four_overload_methods(self, x: bytes) -> bytes: ... + + # comment after third with large gaps below and above + @overload + def four_overload_methods(self, x: list[bytes]) -> bytes: ... + +@overload +def commented_gap_above(x: int) -> int: ... + +# comment with gap above that is retained +@overload +def commented_gap_above(x: str) -> str: ... + +@overload +def commented_gap_below(x: int) -> int: ... +# comment with gap below that is removed +@overload +def commented_gap_below(x: str) -> str: ... + +@overload +def commented_gaps_both(x: int) -> int: ... + +# comment with gaps on both sides +@overload +def commented_gaps_both(x: str) -> str: ... + +@overload +def multi_comment(x: int) -> int: ... +# first comment +# second comment +@overload +def multi_comment(x: str) -> str: ... + +@overload +def large_comment_gaps(x: int) -> int: ... + +# comment with large gaps above that are collapsed +@overload +def large_comment_gaps(x: str) -> str: ... + +# comment with large gaps above and below that are collapsed +@overload +def large_comment_gaps(x: int) -> int: ... + +@overload +def conditional_commented(x: int) -> int: ... + +# comment + +if sys.version_info >= (3, 10): + + # comment + @overload + def conditional_commented(x: str) -> str: ... +else: + + # comment + @overload + def conditional_commented(x: str) -> str: ... + +def before_comment_group() -> None: ... + +# comment before overload group +@overload +def comment_before(x: int) -> int: ... +@overload +def comment_before(x: str) -> str: ... + +def after_comment_group() -> None: ... + +class ClassWithConditionalOverloads: + def method(self) -> None: ... + + if sys.version_info >= (3, 10): + @overload + def conditional(self, x: int) -> int: ... + else: + @overload + def conditional(self, x: str) -> str: ... + + @overload + def conditional(self, x: bytes) -> bytes: ... + + @overload + def conditional_commented(self, x: int) -> int: ... + + # comment + + if sys.version_info >= (3, 10): + + # comment + @overload + def conditional_commented(self, x: str) -> str: ... + else: + + # comment + @overload + def conditional_commented(self, x: str) -> str: ... + +class ClassWithOverloadThenConditional: + @overload + def method(self, x: int) -> int: ... + @overload + def method(self, x: str) -> str: ... + if sys.version_info >= (3, 10): + @overload + def method(self, x: bytes) -> bytes: ... + +class ClassWithNonOverloadConditional: + def regular(self) -> None: ... + if sys.version_info < (3, 12): + @staticmethod + def legacy_method() -> str: + """Deprecated.""" + +@type_check_only +class DecoratedClassWithUndecoratedMethods: + def method_a(self) -> None: ... + def method_b(self) -> None: ... + def method_c(self) -> None: ... + +if sys.version_info >= (3, 12): + @overload + def elif_overload(x: int) -> int: ... +elif sys.version_info >= (3, 10): + @overload + def elif_overload(x: float) -> float: ... +else: + @overload + def elif_overload(x: bytes) -> bytes: ... + +@overload +def elif_overload(x: str) -> str: ... + +@overload +def before_class(x: int) -> int: ... +@overload +def before_class(x: str) -> str: ... + +class AfterOverloadGroup: ... +class AfterOverloadGroup2: ... + +@overload +def after_class(x: int) -> int: ... +@overload +def after_class(x: str) -> str: ... + +@overload +@decorator +def multi_decorated(x: int) -> int: ... +@overload +@decorator +def multi_decorated(x: str) -> str: ... + +def after_multi_decorated() -> None: ... + +class Outer: + class Inner: + @overload + def method(self, x: int) -> int: ... + @overload + def method(self, x: str) -> str: ... + + @overload + def method(self, x: int) -> int: ... + @overload + def method(self, x: str) -> str: ... diff --git a/tests/data/cases/python315.py b/tests/data/cases/python315.py new file mode 100644 index 0000000..127eca2 --- /dev/null +++ b/tests/data/cases/python315.py @@ -0,0 +1,52 @@ +# flags: --fast +lazy import json +lazy from package.subpackage import ( + alpha, + beta, + gamma, +) +from .lazy import thing + +lazy = "still an identifier" + + +def eager(): + lazy = "still an identifier" + return lazy + + +flattened = [*item for item in items] +generator = (*item for item in items) +combined = {*members for members in groups} +merged = {**mapping for mapping in mappings} + + +async def collect(): + return [*item async for item in items_async] + + +# output +lazy import json +lazy from package.subpackage import ( + alpha, + beta, + gamma, +) +from .lazy import thing + +lazy = "still an identifier" + + +def eager(): + lazy = "still an identifier" + return lazy + + +flattened = [*item for item in items] +generator = (*item for item in items) +combined = {*members for members in groups} +merged = {**mapping for mapping in mappings} + + +async def collect(): + return [*item async for item in items_async] diff --git a/tests/data/cases/python37.py b/tests/data/cases/python37.py new file mode 100644 index 0000000..a600621 --- /dev/null +++ b/tests/data/cases/python37.py @@ -0,0 +1,61 @@ +def f(): + return (i * 2 async for i in arange(42)) + + +def g(): + return ( + something_long * something_long + async for something_long in async_generator(with_an_argument) + ) + + +async def func(): + await ... + if test: + out_batched = [ + i + async for i in aitertools._async_map( + self.async_inc, arange(8), batch_size=3 + ) + ] + + +def awaited_generator_value(n): + return (await awaitable for awaitable in awaitable_list) + + +def make_arange(n): + return (i * 2 for i in range(n) if await wrap(i)) + + +# output + + +def f(): + return (i * 2 async for i in arange(42)) + + +def g(): + return ( + something_long * something_long + async for something_long in async_generator(with_an_argument) + ) + + +async def func(): + await ... + if test: + out_batched = [ + i + async for i in aitertools._async_map( + self.async_inc, arange(8), batch_size=3 + ) + ] + + +def awaited_generator_value(n): + return (await awaitable for awaitable in awaitable_list) + + +def make_arange(n): + return (i * 2 for i in range(n) if await wrap(i)) diff --git a/tests/data/cases/python38.py b/tests/data/cases/python38.py new file mode 100644 index 0000000..715641b --- /dev/null +++ b/tests/data/cases/python38.py @@ -0,0 +1,39 @@ +def starred_return(): + my_list = ["value2", "value3"] + return "value1", *my_list + + +def starred_yield(): + my_list = ["value2", "value3"] + yield "value1", *my_list + + +# all right hand side expressions allowed in regular assignments are now also allowed in +# annotated assignments +a : Tuple[ str, int] = "1", 2 +a: Tuple[int , ... ] = b, *c, d +def t(): + a : str = yield "a" + + +# output + + +def starred_return(): + my_list = ["value2", "value3"] + return "value1", *my_list + + +def starred_yield(): + my_list = ["value2", "value3"] + yield "value1", *my_list + + +# all right hand side expressions allowed in regular assignments are now also allowed in +# annotated assignments +a: Tuple[str, int] = "1", 2 +a: Tuple[int, ...] = b, *c, d + + +def t(): + a: str = yield "a" diff --git a/tests/data/cases/python39.py b/tests/data/cases/python39.py new file mode 100644 index 0000000..719c2b5 --- /dev/null +++ b/tests/data/cases/python39.py @@ -0,0 +1,28 @@ +@relaxed_decorator[0] +def f(): + ... + +@relaxed_decorator[extremely_long_name_that_definitely_will_not_fit_on_one_line_of_standard_length] +def f(): + ... + +@extremely_long_variable_name_that_doesnt_fit := complex.expression(with_long="arguments_value_that_wont_fit_at_the_end_of_the_line") +def f(): + ... + +# output + +@relaxed_decorator[0] +def f(): ... + + +@relaxed_decorator[ + extremely_long_name_that_definitely_will_not_fit_on_one_line_of_standard_length +] +def f(): ... + + +@extremely_long_variable_name_that_doesnt_fit := complex.expression( + with_long="arguments_value_that_wont_fit_at_the_end_of_the_line" +) +def f(): ... \ No newline at end of file diff --git a/tests/data/cases/raw_docstring.py b/tests/data/cases/raw_docstring.py new file mode 100644 index 0000000..7f88bb2 --- /dev/null +++ b/tests/data/cases/raw_docstring.py @@ -0,0 +1,32 @@ +# flags: --skip-string-normalization +class C: + + r"""Raw""" + +def f(): + + r"""Raw""" + +class SingleQuotes: + + + r'''Raw''' + +class UpperCaseR: + R"""Raw""" + +# output +class C: + r"""Raw""" + + +def f(): + r"""Raw""" + + +class SingleQuotes: + r'''Raw''' + + +class UpperCaseR: + R"""Raw""" diff --git a/tests/data/cases/raw_docstring_no_string_normalization.py b/tests/data/cases/raw_docstring_no_string_normalization.py new file mode 100644 index 0000000..a201c1e --- /dev/null +++ b/tests/data/cases/raw_docstring_no_string_normalization.py @@ -0,0 +1,11 @@ +# flags: --skip-string-normalization +def do_not_touch_this_prefix(): + R"""There was a bug where docstring prefixes would be normalized even with -S.""" + + +def do_not_touch_this_prefix2(): + FR'There was a bug where docstring prefixes would be normalized even with -S.' + + +def do_not_touch_this_prefix3(): + u'''There was a bug where docstring prefixes would be normalized even with -S.''' diff --git a/tests/data/cases/remove_await_parens.py b/tests/data/cases/remove_await_parens.py new file mode 100644 index 0000000..073150c --- /dev/null +++ b/tests/data/cases/remove_await_parens.py @@ -0,0 +1,195 @@ +import asyncio + +# Control example +async def main(): + await asyncio.sleep(1) + +# Remove brackets for short coroutine/task +async def main(): + await (asyncio.sleep(1)) + +async def main(): + await ( + asyncio.sleep(1) + ) + +async def main(): + await (asyncio.sleep(1) + ) + +# Check comments +async def main(): + await ( # Hello + asyncio.sleep(1) + ) + +async def main(): + await ( + asyncio.sleep(1) # Hello + ) + +async def main(): + await ( + asyncio.sleep(1) + ) # Hello + +# Long lines +async def main(): + await asyncio.gather(asyncio.sleep(1), asyncio.sleep(1), asyncio.sleep(1), asyncio.sleep(1), asyncio.sleep(1), asyncio.sleep(1), asyncio.sleep(1)) + +# Same as above but with magic trailing comma in function +async def main(): + await asyncio.gather(asyncio.sleep(1), asyncio.sleep(1), asyncio.sleep(1), asyncio.sleep(1), asyncio.sleep(1), asyncio.sleep(1), asyncio.sleep(1),) + +# Cr@zY Br@ck3Tz +async def main(): + await ( + ((((((((((((( + ((( ((( + ((( ((( + ((( ((( + ((( ((( + ((black(1))) + ))) ))) + ))) ))) + ))) ))) + ))) ))) + ))))))))))))) + ) + +# Keep brackets around non power operations and nested awaits +async def main(): + await (set_of_tasks | other_set) + +async def main(): + await (await asyncio.sleep(1)) + +# It's awaits all the way down... +async def main(): + await (await x) + +async def main(): + await (yield x) + +async def main(): + await (await (asyncio.sleep(1))) + +async def main(): + await (await (await (await (await (asyncio.sleep(1)))))) + +async def main(): + await (yield) + +async def main(): + await (a ** b) + await (a[b] ** c) + await (a ** b[c]) + await ((a + b) ** (c + d)) + await (a + b) + await (a[b]) + await (a[b ** c]) + +# output +import asyncio + + +# Control example +async def main(): + await asyncio.sleep(1) + + +# Remove brackets for short coroutine/task +async def main(): + await asyncio.sleep(1) + + +async def main(): + await asyncio.sleep(1) + + +async def main(): + await asyncio.sleep(1) + + +# Check comments +async def main(): + await asyncio.sleep(1) # Hello + + +async def main(): + await asyncio.sleep(1) # Hello + + +async def main(): + await asyncio.sleep(1) # Hello + + +# Long lines +async def main(): + await asyncio.gather( + asyncio.sleep(1), + asyncio.sleep(1), + asyncio.sleep(1), + asyncio.sleep(1), + asyncio.sleep(1), + asyncio.sleep(1), + asyncio.sleep(1), + ) + + +# Same as above but with magic trailing comma in function +async def main(): + await asyncio.gather( + asyncio.sleep(1), + asyncio.sleep(1), + asyncio.sleep(1), + asyncio.sleep(1), + asyncio.sleep(1), + asyncio.sleep(1), + asyncio.sleep(1), + ) + + +# Cr@zY Br@ck3Tz +async def main(): + await black(1) + + +# Keep brackets around non power operations and nested awaits +async def main(): + await (set_of_tasks | other_set) + + +async def main(): + await (await asyncio.sleep(1)) + + +# It's awaits all the way down... +async def main(): + await (await x) + + +async def main(): + await (yield x) + + +async def main(): + await (await asyncio.sleep(1)) + + +async def main(): + await (await (await (await (await asyncio.sleep(1))))) + + +async def main(): + await (yield) + + +async def main(): + await (a**b) + await (a[b] ** c) + await (a ** b[c]) + await ((a + b) ** (c + d)) + await (a + b) + await a[b] + await a[b**c] diff --git a/tests/data/cases/remove_except_parens.py b/tests/data/cases/remove_except_parens.py new file mode 100644 index 0000000..322c5b7 --- /dev/null +++ b/tests/data/cases/remove_except_parens.py @@ -0,0 +1,79 @@ +# These brackets are redundant, therefore remove. +try: + a.something +except (AttributeError) as err: + raise err + +# This is tuple of exceptions. +# Although this could be replaced with just the exception, +# we do not remove brackets to preserve AST. +try: + a.something +except (AttributeError,) as err: + raise err + +# This is a tuple of exceptions. Do not remove brackets. +try: + a.something +except (AttributeError, ValueError) as err: + raise err + +# Test long variants. +try: + a.something +except (some.really.really.really.looooooooooooooooooooooooooooooooong.module.over89.chars.Error) as err: + raise err + +try: + a.something +except (some.really.really.really.looooooooooooooooooooooooooooooooong.module.over89.chars.Error,) as err: + raise err + +try: + a.something +except (some.really.really.really.looooooooooooooooooooooooooooooooong.module.over89.chars.Error, some.really.really.really.looooooooooooooooooooooooooooooooong.module.over89.chars.Error) as err: + raise err + +# output +# These brackets are redundant, therefore remove. +try: + a.something +except AttributeError as err: + raise err + +# This is tuple of exceptions. +# Although this could be replaced with just the exception, +# we do not remove brackets to preserve AST. +try: + a.something +except (AttributeError,) as err: + raise err + +# This is a tuple of exceptions. Do not remove brackets. +try: + a.something +except (AttributeError, ValueError) as err: + raise err + +# Test long variants. +try: + a.something +except ( + some.really.really.really.looooooooooooooooooooooooooooooooong.module.over89.chars.Error +) as err: + raise err + +try: + a.something +except ( + some.really.really.really.looooooooooooooooooooooooooooooooong.module.over89.chars.Error, +) as err: + raise err + +try: + a.something +except ( + some.really.really.really.looooooooooooooooooooooooooooooooong.module.over89.chars.Error, + some.really.really.really.looooooooooooooooooooooooooooooooong.module.over89.chars.Error, +) as err: + raise err diff --git a/tests/data/cases/remove_except_types_parens.py b/tests/data/cases/remove_except_types_parens.py new file mode 100644 index 0000000..463be7e --- /dev/null +++ b/tests/data/cases/remove_except_types_parens.py @@ -0,0 +1,249 @@ +# flags: --minimum-version=3.14 +# SEE PEP 758 FOR MORE DETAILS +# remains unchanged +try: + pass +except: + pass + +# remains unchanged +try: + pass +except ValueError: + pass + +try: + pass +except* ValueError: + pass + +# parenthesis are removed +try: + pass +except (ValueError): + pass + +try: + pass +except* (ValueError): + pass + +# parenthesis are removed +try: + pass +except (ValueError) as e: + pass + +try: + pass +except* (ValueError) as e: + pass + +# remains unchanged +try: + pass +except (ValueError,): + pass + +try: + pass +except* (ValueError,): + pass + +# remains unchanged +try: + pass +except (ValueError,) as e: + pass + +try: + pass +except* (ValueError,) as e: + pass + +# remains unchanged +try: + pass +except ValueError, TypeError, KeyboardInterrupt: + pass + +try: + pass +except* ValueError, TypeError, KeyboardInterrupt: + pass + +# parenthesis are removed +try: + pass +except (ValueError, TypeError, KeyboardInterrupt): + pass + +try: + pass +except* (ValueError, TypeError, KeyboardInterrupt): + pass + +# parenthesis are not removed +try: + pass +except (ValueError, TypeError, KeyboardInterrupt) as e: + pass + +try: + pass +except* (ValueError, TypeError, KeyboardInterrupt) as e: + pass + +# parenthesis are removed +try: + pass +except (ValueError if True else TypeError): + pass + +try: + pass +except* (ValueError if True else TypeError): + pass + +# inner except: parenthesis are removed +# outer except: parenthsis are not removed +try: + try: + pass + except (TypeError, KeyboardInterrupt): + pass +except (ValueError,): + pass + +try: + try: + pass + except* (TypeError, KeyboardInterrupt): + pass +except* (ValueError,): + pass + +# output +# SEE PEP 758 FOR MORE DETAILS +# remains unchanged +try: + pass +except: + pass + +# remains unchanged +try: + pass +except ValueError: + pass + +try: + pass +except* ValueError: + pass + +# parenthesis are removed +try: + pass +except ValueError: + pass + +try: + pass +except* ValueError: + pass + +# parenthesis are removed +try: + pass +except ValueError as e: + pass + +try: + pass +except* ValueError as e: + pass + +# remains unchanged +try: + pass +except (ValueError,): + pass + +try: + pass +except* (ValueError,): + pass + +# remains unchanged +try: + pass +except (ValueError,) as e: + pass + +try: + pass +except* (ValueError,) as e: + pass + +# remains unchanged +try: + pass +except ValueError, TypeError, KeyboardInterrupt: + pass + +try: + pass +except* ValueError, TypeError, KeyboardInterrupt: + pass + +# parenthesis are removed +try: + pass +except ValueError, TypeError, KeyboardInterrupt: + pass + +try: + pass +except* ValueError, TypeError, KeyboardInterrupt: + pass + +# parenthesis are not removed +try: + pass +except (ValueError, TypeError, KeyboardInterrupt) as e: + pass + +try: + pass +except* (ValueError, TypeError, KeyboardInterrupt) as e: + pass + +# parenthesis are removed +try: + pass +except ValueError if True else TypeError: + pass + +try: + pass +except* ValueError if True else TypeError: + pass + +# inner except: parenthesis are removed +# outer except: parenthsis are not removed +try: + try: + pass + except TypeError, KeyboardInterrupt: + pass +except (ValueError,): + pass + +try: + try: + pass + except* TypeError, KeyboardInterrupt: + pass +except* (ValueError,): + pass diff --git a/tests/data/cases/remove_except_types_parens_pre_py314.py b/tests/data/cases/remove_except_types_parens_pre_py314.py new file mode 100644 index 0000000..acd2458 --- /dev/null +++ b/tests/data/cases/remove_except_types_parens_pre_py314.py @@ -0,0 +1,225 @@ +# flags: --minimum-version=3.11 +# SEE PEP 758 FOR MORE DETAILS +# remains unchanged +try: + pass +except: + pass + +# remains unchanged +try: + pass +except ValueError: + pass + +try: + pass +except* ValueError: + pass + +# parenthesis are removed +try: + pass +except (ValueError): + pass + +try: + pass +except* (ValueError): + pass + +# parenthesis are removed +try: + pass +except (ValueError) as e: + pass + +try: + pass +except* (ValueError) as e: + pass + +# remains unchanged +try: + pass +except (ValueError,): + pass + +try: + pass +except* (ValueError,): + pass + +# remains unchanged +try: + pass +except (ValueError,) as e: + pass + +try: + pass +except* (ValueError,) as e: + pass + +# parenthesis are not removed +try: + pass +except (ValueError, TypeError, KeyboardInterrupt): + pass + +try: + pass +except* (ValueError, TypeError, KeyboardInterrupt): + pass + +# parenthesis are not removed +try: + pass +except (ValueError, TypeError, KeyboardInterrupt) as e: + pass + +try: + pass +except* (ValueError, TypeError, KeyboardInterrupt) as e: + pass + +# parenthesis are removed +try: + pass +except (ValueError if True else TypeError): + pass + +try: + pass +except* (ValueError if True else TypeError): + pass + +# parenthesis are not removed +try: + try: + pass + except (TypeError, KeyboardInterrupt): + pass +except (ValueError,): + pass + +try: + try: + pass + except* (TypeError, KeyboardInterrupt): + pass +except* (ValueError,): + pass + +# output +# SEE PEP 758 FOR MORE DETAILS +# remains unchanged +try: + pass +except: + pass + +# remains unchanged +try: + pass +except ValueError: + pass + +try: + pass +except* ValueError: + pass + +# parenthesis are removed +try: + pass +except ValueError: + pass + +try: + pass +except* ValueError: + pass + +# parenthesis are removed +try: + pass +except ValueError as e: + pass + +try: + pass +except* ValueError as e: + pass + +# remains unchanged +try: + pass +except (ValueError,): + pass + +try: + pass +except* (ValueError,): + pass + +# remains unchanged +try: + pass +except (ValueError,) as e: + pass + +try: + pass +except* (ValueError,) as e: + pass + +# parenthesis are not removed +try: + pass +except (ValueError, TypeError, KeyboardInterrupt): + pass + +try: + pass +except* (ValueError, TypeError, KeyboardInterrupt): + pass + +# parenthesis are not removed +try: + pass +except (ValueError, TypeError, KeyboardInterrupt) as e: + pass + +try: + pass +except* (ValueError, TypeError, KeyboardInterrupt) as e: + pass + +# parenthesis are removed +try: + pass +except ValueError if True else TypeError: + pass + +try: + pass +except* ValueError if True else TypeError: + pass + +# parenthesis are not removed +try: + try: + pass + except (TypeError, KeyboardInterrupt): + pass +except (ValueError,): + pass + +try: + try: + pass + except* (TypeError, KeyboardInterrupt): + pass +except* (ValueError,): + pass diff --git a/tests/data/cases/remove_for_brackets.py b/tests/data/cases/remove_for_brackets.py new file mode 100644 index 0000000..cd53404 --- /dev/null +++ b/tests/data/cases/remove_for_brackets.py @@ -0,0 +1,48 @@ +# Only remove tuple brackets after `for` +for (k, v) in d.items(): + print(k, v) + +# Don't touch tuple brackets after `in` +for module in (core, _unicodefun): + if hasattr(module, "_verify_python3_env"): + module._verify_python3_env = lambda: None + +# Brackets remain for long for loop lines +for (why_would_anyone_choose_to_name_a_loop_variable_with_a_name_this_long, i_dont_know_but_we_should_still_check_the_behaviour_if_they_do) in d.items(): + print(k, v) + +for (k, v) in dfkasdjfldsjflkdsjflkdsjfdslkfjldsjfgkjdshgkljjdsfldgkhsdofudsfudsofajdslkfjdslkfjldisfjdffjsdlkfjdlkjjkdflskadjldkfjsalkfjdasj.items(): + print(k, v) + +# Test deeply nested brackets +for (((((k, v))))) in d.items(): + print(k, v) + +# output +# Only remove tuple brackets after `for` +for k, v in d.items(): + print(k, v) + +# Don't touch tuple brackets after `in` +for module in (core, _unicodefun): + if hasattr(module, "_verify_python3_env"): + module._verify_python3_env = lambda: None + +# Brackets remain for long for loop lines +for ( + why_would_anyone_choose_to_name_a_loop_variable_with_a_name_this_long, + i_dont_know_but_we_should_still_check_the_behaviour_if_they_do, +) in d.items(): + print(k, v) + +for ( + k, + v, +) in ( + dfkasdjfldsjflkdsjflkdsjfdslkfjldsjfgkjdshgkljjdsfldgkhsdofudsfudsofajdslkfjdslkfjldisfjdffjsdlkfjdlkjjkdflskadjldkfjsalkfjdasj.items() +): + print(k, v) + +# Test deeply nested brackets +for k, v in d.items(): + print(k, v) diff --git a/tests/data/cases/remove_lone_list_item_parens.py b/tests/data/cases/remove_lone_list_item_parens.py new file mode 100644 index 0000000..8127e03 --- /dev/null +++ b/tests/data/cases/remove_lone_list_item_parens.py @@ -0,0 +1,157 @@ +items = [(123)] +items = [(True)] +items = [(((((True)))))] +items = [(((((True,)))))] +items = [((((()))))] +items = [(x for x in [1])] +items = {(123)} +items = {(True)} +items = {(((((True)))))} + +# Requires `hug_parens_with_braces_and_square_brackets` unstable style to remove parentheses +# around multiline values +items = [ + ( + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} + ) +] +items = [ + ( + {"key1": "val1", "key2": "val2"} + if some_var == "" + else {"key": "val"} + ) +] + +# Comments should not cause crashes +items = [ + ( # comment + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} + ) +] +items = [ + ( + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} + ) # comment +] + +items = [ # comment + ( + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} + ) +] +items = [ + ( + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} + ) +] # comment + +items = [ + ( + {"key1": "val1", "key2": "val2", "key3": "val3"} # comment + if some_var == "long strings" + else {"key": "val"} + ) +] + +items = [ # comment + ( # comment + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} + ) +] +items = [ + ( + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} + ) # comment +] # comment + + +# output +items = [123] +items = [True] +items = [True] +items = [(True,)] +items = [()] +items = [(x for x in [1])] +items = {123} +items = {True} +items = {True} + +# Requires `hug_parens_with_braces_and_square_brackets` unstable style to remove parentheses +# around multiline values +items = [ + ( + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} + ) +] +items = [{"key1": "val1", "key2": "val2"} if some_var == "" else {"key": "val"}] + +# Comments should not cause crashes +items = [ + ( # comment + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} + ) +] +items = [ + ( + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} + ) # comment +] + +items = [ # comment + ( + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} + ) +] +items = [ + ( + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} + ) +] # comment + +items = [ + ( + {"key1": "val1", "key2": "val2", "key3": "val3"} # comment + if some_var == "long strings" + else {"key": "val"} + ) +] + +items = [ # comment + ( # comment + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} + ) +] +items = [ + ( + {"key1": "val1", "key2": "val2", "key3": "val3"} + if some_var == "long strings" + else {"key": "val"} + ) # comment +] # comment diff --git a/tests/data/cases/remove_newline_after_code_block_open.py b/tests/data/cases/remove_newline_after_code_block_open.py new file mode 100644 index 0000000..6622e8a --- /dev/null +++ b/tests/data/cases/remove_newline_after_code_block_open.py @@ -0,0 +1,212 @@ +import random + + +def foo1(): + + print("The newline above me should be kept!") + + +def foo2(): + + + + print("All the newlines above me should be kept!") + + +def foo3(): + + print("No newline above me!") + + print("There is a newline above me, and that's OK!") + + +def foo4(): + + # There is a comment here + + print("The newline above me should not be deleted!") + + +class Foo: + def bar(self): + + print("The newline above me should be kept!") + + +for i in range(5): + + print(f"{i}) The line above me should be kept!") + + +for i in range(5): + + + + print(f"{i}) The lines above me should be kept!") + + +for i in range(5): + + for j in range(7): + + print(f"{i}) The lines above me should be kept!") + + +if random.randint(0, 3) == 0: + + print("The new line above me will be kept!") + + +if random.randint(0, 3) == 0: + + + + + print("The new lines above me will be kept!") + + +if random.randint(0, 3) == 0: + + if random.uniform(0, 1) > 0.5: + + print("Two lines above me will be kept!") + + +while True: + + print("The newline above me should be kept!") + + +while True: + + + + print("The newlines above me should be kept!") + + +while True: + + while False: + + print("The newlines above me should be kept!") + + +with open("/path/to/file.txt", mode="w") as file: + + file.write("The new line above me will be kept!") + + +with open("/path/to/file.txt", mode="w") as file: + + + + file.write("The new lines above me will be kept!") + + +with open("/path/to/file.txt", mode="r") as read_file: + + with open("/path/to/output_file.txt", mode="w") as write_file: + + write_file.writelines(read_file.readlines()) + +# output + +import random + + +def foo1(): + + print("The newline above me should be kept!") + + +def foo2(): + + print("All the newlines above me should be kept!") + + +def foo3(): + + print("No newline above me!") + + print("There is a newline above me, and that's OK!") + + +def foo4(): + + # There is a comment here + + print("The newline above me should not be deleted!") + + +class Foo: + def bar(self): + + print("The newline above me should be kept!") + + +for i in range(5): + + print(f"{i}) The line above me should be kept!") + + +for i in range(5): + + print(f"{i}) The lines above me should be kept!") + + +for i in range(5): + + for j in range(7): + + print(f"{i}) The lines above me should be kept!") + + +if random.randint(0, 3) == 0: + + print("The new line above me will be kept!") + + +if random.randint(0, 3) == 0: + + print("The new lines above me will be kept!") + + +if random.randint(0, 3) == 0: + + if random.uniform(0, 1) > 0.5: + + print("Two lines above me will be kept!") + + +while True: + + print("The newline above me should be kept!") + + +while True: + + print("The newlines above me should be kept!") + + +while True: + + while False: + + print("The newlines above me should be kept!") + + +with open("/path/to/file.txt", mode="w") as file: + + file.write("The new line above me will be kept!") + + +with open("/path/to/file.txt", mode="w") as file: + + file.write("The new lines above me will be kept!") + + +with open("/path/to/file.txt", mode="r") as read_file: + + with open("/path/to/output_file.txt", mode="w") as write_file: + + write_file.writelines(read_file.readlines()) diff --git a/tests/data/cases/remove_parens.py b/tests/data/cases/remove_parens.py new file mode 100644 index 0000000..abd5f71 --- /dev/null +++ b/tests/data/cases/remove_parens.py @@ -0,0 +1,142 @@ +x = (1) +x = (1.2) + +data = ( + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +).encode() + +async def show_status(): + while True: + try: + if report_host: + data = ( + f"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" + ).encode() + except Exception as e: + pass + +def example(): + return (("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")) + + +def example1(): + return ((1111111111111111111111111111111111111111111111111111111111111111111111111111111111111)) + + +def example1point5(): + return ((((((1111111111111111111111111111111111111111111111111111111111111111111111111111111111111)))))) + + +def example2(): + return (("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")) + + +def example3(): + return ((1111111111111111111111111111111111111111111111111111111111111111111111111111111)) + + +def example4(): + return ((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((True)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) + + +def example5(): + return ((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) + + +def example6(): + return ((((((((({a:a for a in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17]}))))))))) + + +def example7(): + return ((((((((({a:a for a in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20000000000000000000]}))))))))) + + +def example8(): + return (((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((None))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) + +# output +x = 1 +x = 1.2 + +data = ( + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +).encode() + + +async def show_status(): + while True: + try: + if report_host: + data = ( + f"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" + ).encode() + except Exception as e: + pass + + +def example(): + return "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" + + +def example1(): + return 1111111111111111111111111111111111111111111111111111111111111111111111111111111111111 + + +def example1point5(): + return 1111111111111111111111111111111111111111111111111111111111111111111111111111111111111 + + +def example2(): + return ( + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" + ) + + +def example3(): + return ( + 1111111111111111111111111111111111111111111111111111111111111111111111111111111 + ) + + +def example4(): + return True + + +def example5(): + return () + + +def example6(): + return {a: a for a in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17]} + + +def example7(): + return { + a: a + for a in [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 20000000000000000000, + ] + } + + +def example8(): + return None diff --git a/tests/data/cases/remove_parens_from_lhs.py b/tests/data/cases/remove_parens_from_lhs.py new file mode 100644 index 0000000..b172aa7 --- /dev/null +++ b/tests/data/cases/remove_parens_from_lhs.py @@ -0,0 +1,35 @@ +# Remove unnecessary parentheses from LHS of assignments + + +def a(): + return [1, 2, 3] + + +# Single variable with unnecessary parentheses +(b) = a()[0] + +# Tuple unpacking with unnecessary parentheses +(c, *_) = a() + +# These should not be changed - parentheses are necessary +(d,) = a() # single-element tuple +e = (1 + 2) * 3 # RHS has precedence needs + +# output + +# Remove unnecessary parentheses from LHS of assignments + + +def a(): + return [1, 2, 3] + + +# Single variable with unnecessary parentheses +b = a()[0] + +# Tuple unpacking with unnecessary parentheses +c, *_ = a() + +# These should not be changed - parentheses are necessary +(d,) = a() # single-element tuple +e = (1 + 2) * 3 # RHS has precedence needs diff --git a/tests/data/cases/remove_redundant_parens_in_case_guard.py b/tests/data/cases/remove_redundant_parens_in_case_guard.py new file mode 100644 index 0000000..4739fc5 --- /dev/null +++ b/tests/data/cases/remove_redundant_parens_in_case_guard.py @@ -0,0 +1,114 @@ +# flags: --minimum-version=3.10 --line-length=79 + +match 1: + case _ if (True): + pass + + +match 1: + case _ if ( + True + ): + pass + + +match 1: + case _ if ( + # this is a comment + True + ): + pass + + +match 1: + case _ if ( + True + # this is a comment + ): + pass + + +match 1: + case _ if ( + True # this is a comment + ): + pass + + +match 1: + case _ if ( # this is a comment + True + ): + pass + + +match 1: + case _ if ( + True + ): # this is a comment + pass + + +match 1: + case _ if (True): # comment over the line limit unless parens are removed x + pass + + +match 1: + case _ if (True): # comment over the line limit and parens should go to next line + pass + + +# output + +match 1: + case _ if True: + pass + + +match 1: + case _ if True: + pass + + +match 1: + case _ if ( + # this is a comment + True + ): + pass + + +match 1: + case _ if ( + True + # this is a comment + ): + pass + + +match 1: + case _ if True: # this is a comment + pass + + +match 1: + case _ if True: # this is a comment + pass + + +match 1: + case _ if True: # this is a comment + pass + + +match 1: + case _ if True: # comment over the line limit unless parens are removed x + pass + + +match 1: + case ( + _ + ) if True: # comment over the line limit and parens should go to next line + pass diff --git a/tests/data/cases/remove_with_brackets.py b/tests/data/cases/remove_with_brackets.py new file mode 100644 index 0000000..f2319e0 --- /dev/null +++ b/tests/data/cases/remove_with_brackets.py @@ -0,0 +1,145 @@ +with (open("bla.txt")): + pass + +with (open("bla.txt")), (open("bla.txt")): + pass + +with (open("bla.txt") as f): + pass + +# Remove brackets within alias expression +with (open("bla.txt")) as f: + pass + +# Remove brackets around one-line context managers +with (open("bla.txt") as f, (open("x"))): + pass + +with ((open("bla.txt")) as f, open("x")): + pass + +with (CtxManager1() as example1, CtxManager2() as example2): + ... + +# Brackets remain when using magic comma +with (CtxManager1() as example1, CtxManager2() as example2,): + ... + +# Brackets remain for multi-line context managers +with (CtxManager1() as example1, CtxManager2() as example2, CtxManager2() as example2, CtxManager2() as example2, CtxManager2() as example2): + ... + +# Don't touch assignment expressions +with (y := open("./test.py")) as f: + pass + +# Deeply nested examples +# N.B. Multiple brackets are only possible +# around the context manager itself. +# Only one brackets is allowed around the +# alias expression or comma-delimited context managers. +with (((open("bla.txt")))): + pass + +with (((open("bla.txt")))), (((open("bla.txt")))): + pass + +with (((open("bla.txt")))) as f: + pass + +with ((((open("bla.txt")))) as f): + pass + +with ((((CtxManager1()))) as example1, (((CtxManager2()))) as example2): + ... + +# regression tests for #3678 +with (a, *b): + pass + +with (a, (b, *c)): + pass + +with (a for b in c): + pass + +with (a, (b for c in d)): + pass + +# output +with open("bla.txt"): + pass + +with open("bla.txt"), open("bla.txt"): + pass + +with open("bla.txt") as f: + pass + +# Remove brackets within alias expression +with open("bla.txt") as f: + pass + +# Remove brackets around one-line context managers +with open("bla.txt") as f, open("x"): + pass + +with open("bla.txt") as f, open("x"): + pass + +with CtxManager1() as example1, CtxManager2() as example2: + ... + +# Brackets remain when using magic comma +with ( + CtxManager1() as example1, + CtxManager2() as example2, +): + ... + +# Brackets remain for multi-line context managers +with ( + CtxManager1() as example1, + CtxManager2() as example2, + CtxManager2() as example2, + CtxManager2() as example2, + CtxManager2() as example2, +): + ... + +# Don't touch assignment expressions +with (y := open("./test.py")) as f: + pass + +# Deeply nested examples +# N.B. Multiple brackets are only possible +# around the context manager itself. +# Only one brackets is allowed around the +# alias expression or comma-delimited context managers. +with open("bla.txt"): + pass + +with open("bla.txt"), open("bla.txt"): + pass + +with open("bla.txt") as f: + pass + +with open("bla.txt") as f: + pass + +with CtxManager1() as example1, CtxManager2() as example2: + ... + +# regression tests for #3678 +with (a, *b): + pass + +with a, (b, *c): + pass + +with (a for b in c): + pass + +with a, (b for c in d): + pass diff --git a/tests/data/cases/return_annotation_brackets.py b/tests/data/cases/return_annotation_brackets.py new file mode 100644 index 0000000..ed05bed --- /dev/null +++ b/tests/data/cases/return_annotation_brackets.py @@ -0,0 +1,219 @@ +# Control +def double(a: int) -> int: + return 2*a + +# Remove the brackets +def double(a: int) -> (int): + return 2*a + +# Some newline variations +def double(a: int) -> ( + int): + return 2*a + +def double(a: int) -> (int +): + return 2*a + +def double(a: int) -> ( + int +): + return 2*a + +# Don't lose the comments +def double(a: int) -> ( # Hello + int +): + return 2*a + +def double(a: int) -> ( + int # Hello +): + return 2*a + +# Really long annotations +def foo() -> ( + intsdfsafafafdfdsasdfsfsdfasdfafdsafdfdsfasdskdsdsfdsafdsafsdfdasfffsfdsfdsafafhdskfhdsfjdslkfdlfsdkjhsdfjkdshfkljds +): + return 2 + +def foo() -> intsdfsafafafdfdsasdfsfsdfasdfafdsafdfdsfasdskdsdsfdsafdsafsdfdasfffsfdsfdsafafhdskfhdsfjdslkfdlfsdkjhsdfjkdshfkljds: + return 2 + +def foo() -> intsdfsafafafdfdsasdfsfsdfasdfafdsafdfdsfasdskdsdsfdsafdsafsdfdasfffsfdsfdsafafhdskfhdsfjdslkfdlfsdkjhsdfjkdshfkljds | intsdfsafafafdfdsasdfsfsdfasdfafdsafdfdsfasdskdsdsfdsafdsafsdfdasfffsfdsfdsafafhdskfhdsfjdslkfdlfsdkjhsdfjkdshfkljds: + return 2 + +def foo(a: int, b: int, c: int,) -> intsdfsafafafdfdsasdfsfsdfasdfafdsafdfdsfasdskdsdsfdsafdsafsdfdasfffsfdsfdsafafhdskfhdsfjdslkfdlfsdkjhsdfjkdshfkljds: + return 2 + +def foo(a: int, b: int, c: int,) -> intsdfsafafafdfdsasdfsfsdfasdfafdsafdfdsfasdskdsdsfdsafdsafsdfdasfffsfdsfdsafafhdskfhdsfjdslkfdlfsdkjhsdfjkdshfkljds | intsdfsafafafdfdsasdfsfsdfasdfafdsafdfdsfasdskdsdsfdsafdsafsdfdasfffsfdsfdsafafhdskfhdsfjdslkfdlfsdkjhsdfjkdshfkljds: + return 2 + +# Split args but no need to split return +def foo(a: int, b: int, c: int,) -> int: + return 2 + +# Deeply nested brackets +# with *interesting* spacing +def double(a: int) -> (((((int))))): + return 2*a + +def double(a: int) -> ( + ( ( + ((int) + ) + ) + ) + ): + return 2*a + +def foo() -> ( + ( ( + intsdfsafafafdfdsasdfsfsdfasdfafdsafdfdsfasdskdsdsfdsafdsafsdfdasfffsfdsfdsafafhdskfhdsfjdslkfdlfsdkjhsdfjkdshfkljds +) +)): + return 2 + +# Return type with commas +def foo() -> ( + tuple[int, int, int] +): + return 2 + +def foo() -> tuple[loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong, loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong, loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong]: + return 2 + +# Magic trailing comma example +def foo() -> tuple[int, int, int,]: + return 2 + +# Magic trailing comma example, with params +def foo(a,b) -> tuple[int, int, int,]: + return 2 + +# output +# Control +def double(a: int) -> int: + return 2 * a + + +# Remove the brackets +def double(a: int) -> int: + return 2 * a + + +# Some newline variations +def double(a: int) -> int: + return 2 * a + + +def double(a: int) -> int: + return 2 * a + + +def double(a: int) -> int: + return 2 * a + + +# Don't lose the comments +def double(a: int) -> int: # Hello + return 2 * a + + +def double(a: int) -> int: # Hello + return 2 * a + + +# Really long annotations +def foo() -> ( + intsdfsafafafdfdsasdfsfsdfasdfafdsafdfdsfasdskdsdsfdsafdsafsdfdasfffsfdsfdsafafhdskfhdsfjdslkfdlfsdkjhsdfjkdshfkljds +): + return 2 + + +def foo() -> ( + intsdfsafafafdfdsasdfsfsdfasdfafdsafdfdsfasdskdsdsfdsafdsafsdfdasfffsfdsfdsafafhdskfhdsfjdslkfdlfsdkjhsdfjkdshfkljds +): + return 2 + + +def foo() -> ( + intsdfsafafafdfdsasdfsfsdfasdfafdsafdfdsfasdskdsdsfdsafdsafsdfdasfffsfdsfdsafafhdskfhdsfjdslkfdlfsdkjhsdfjkdshfkljds + | intsdfsafafafdfdsasdfsfsdfasdfafdsafdfdsfasdskdsdsfdsafdsafsdfdasfffsfdsfdsafafhdskfhdsfjdslkfdlfsdkjhsdfjkdshfkljds +): + return 2 + + +def foo( + a: int, + b: int, + c: int, +) -> intsdfsafafafdfdsasdfsfsdfasdfafdsafdfdsfasdskdsdsfdsafdsafsdfdasfffsfdsfdsafafhdskfhdsfjdslkfdlfsdkjhsdfjkdshfkljds: + return 2 + + +def foo( + a: int, + b: int, + c: int, +) -> ( + intsdfsafafafdfdsasdfsfsdfasdfafdsafdfdsfasdskdsdsfdsafdsafsdfdasfffsfdsfdsafafhdskfhdsfjdslkfdlfsdkjhsdfjkdshfkljds + | intsdfsafafafdfdsasdfsfsdfasdfafdsafdfdsfasdskdsdsfdsafdsafsdfdasfffsfdsfdsafafhdskfhdsfjdslkfdlfsdkjhsdfjkdshfkljds +): + return 2 + + +# Split args but no need to split return +def foo( + a: int, + b: int, + c: int, +) -> int: + return 2 + + +# Deeply nested brackets +# with *interesting* spacing +def double(a: int) -> int: + return 2 * a + + +def double(a: int) -> int: + return 2 * a + + +def foo() -> ( + intsdfsafafafdfdsasdfsfsdfasdfafdsafdfdsfasdskdsdsfdsafdsafsdfdasfffsfdsfdsafafhdskfhdsfjdslkfdlfsdkjhsdfjkdshfkljds +): + return 2 + + +# Return type with commas +def foo() -> tuple[int, int, int]: + return 2 + + +def foo() -> tuple[ + loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong, + loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong, + loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong, +]: + return 2 + + +# Magic trailing comma example +def foo() -> tuple[ + int, + int, + int, +]: + return 2 + + +# Magic trailing comma example, with params +def foo(a, b) -> tuple[ + int, + int, + int, +]: + return 2 diff --git a/tests/data/cases/single_line_format_skip_with_multiple_comments.py b/tests/data/cases/single_line_format_skip_with_multiple_comments.py new file mode 100644 index 0000000..7212740 --- /dev/null +++ b/tests/data/cases/single_line_format_skip_with_multiple_comments.py @@ -0,0 +1,19 @@ +foo = 123 # fmt: skip # noqa: E501 # pylint +bar = ( + 123 , + ( 1 + 5 ) # pylint # fmt:skip +) +baz = "a" + "b" # pylint; fmt: skip; noqa: E501 +skip_will_not_work = "a" + "b" # pylint fmt:skip +skip_will_not_work2 = "a" + "b" # some text; fmt:skip happens to be part of it + +# output + +foo = 123 # fmt: skip # noqa: E501 # pylint +bar = ( + 123 , + ( 1 + 5 ) # pylint # fmt:skip +) +baz = "a" + "b" # pylint; fmt: skip; noqa: E501 +skip_will_not_work = "a" + "b" # pylint fmt:skip +skip_will_not_work2 = "a" + "b" # some text; fmt:skip happens to be part of it diff --git a/tests/data/cases/skip_magic_trailing_comma.py b/tests/data/cases/skip_magic_trailing_comma.py new file mode 100644 index 0000000..1ef34af --- /dev/null +++ b/tests/data/cases/skip_magic_trailing_comma.py @@ -0,0 +1,75 @@ +# flags: --skip-magic-trailing-comma +# We should not remove the trailing comma in a single-element subscript. +a: tuple[int,] +b = tuple[int,] + +# But commas in multiple element subscripts should be removed. +c: tuple[int, int,] +d = tuple[int, int,] + +# Remove commas for non-subscripts. +small_list = [1,] +list_of_types = [tuple[int,],] +small_set = {1,} +set_of_types = {tuple[int,],} + +# Except single element tuples +small_tuple = (1,) + +# Trailing commas in multiple chained non-nested parens. +zero( + one, +).two( + three, +).four( + five, +) + +func1(arg1).func2(arg2,).func3(arg3).func4(arg4,).func5(arg5) + +( + a, + b, + c, + d, +) = func1( + arg1 +) and func2(arg2) + +func( + argument1, + ( + one, + two, + ), + argument4, + argument5, + argument6, +) + +# output +# We should not remove the trailing comma in a single-element subscript. +a: tuple[int,] +b = tuple[int,] + +# But commas in multiple element subscripts should be removed. +c: tuple[int, int] +d = tuple[int, int] + +# Remove commas for non-subscripts. +small_list = [1] +list_of_types = [tuple[int,]] +small_set = {1} +set_of_types = {tuple[int,]} + +# Except single element tuples +small_tuple = (1,) + +# Trailing commas in multiple chained non-nested parens. +zero(one).two(three).four(five) + +func1(arg1).func2(arg2).func3(arg3).func4(arg4).func5(arg5) + +a, b, c, d = func1(arg1) and func2(arg2) + +func(argument1, (one, two), argument4, argument5, argument6) diff --git a/tests/data/cases/skip_magic_trailing_comma_generic_wrap.py b/tests/data/cases/skip_magic_trailing_comma_generic_wrap.py new file mode 100644 index 0000000..a833f3d --- /dev/null +++ b/tests/data/cases/skip_magic_trailing_comma_generic_wrap.py @@ -0,0 +1,163 @@ +# flags: --minimum-version=3.12 --skip-magic-trailing-comma +def plain[T, B](a: T, b: T) -> T: + return a + +def arg_magic[T, B](a: T, b: T,) -> T: + return a + +def type_param_magic[T, B,](a: T, b: T) -> T: + return a + +def both_magic[T, B,](a: T, b: T,) -> T: + return a + + +def plain_multiline[ + T, + B +]( + a: T, + b: T +) -> T: + return a + +def arg_magic_multiline[ + T, + B +]( + a: T, + b: T, +) -> T: + return a + +def type_param_magic_multiline[ + T, + B, +]( + a: T, + b: T +) -> T: + return a + +def both_magic_multiline[ + T, + B, +]( + a: T, + b: T, +) -> T: + return a + + +def plain_mixed1[ + T, + B +](a: T, b: T) -> T: + return a + +def plain_mixed2[T, B]( + a: T, + b: T +) -> T: + return a + +def arg_magic_mixed1[ + T, + B +](a: T, b: T,) -> T: + return a + +def arg_magic_mixed2[T, B]( + a: T, + b: T, +) -> T: + return a + +def type_param_magic_mixed1[ + T, + B, +](a: T, b: T) -> T: + return a + +def type_param_magic_mixed2[T, B,]( + a: T, + b: T +) -> T: + return a + +def both_magic_mixed1[ + T, + B, +](a: T, b: T,) -> T: + return a + +def both_magic_mixed2[T, B,]( + a: T, + b: T, +) -> T: + return a + + +# output +def plain[T, B](a: T, b: T) -> T: + return a + + +def arg_magic[T, B](a: T, b: T) -> T: + return a + + +def type_param_magic[T, B](a: T, b: T) -> T: + return a + + +def both_magic[T, B](a: T, b: T) -> T: + return a + + +def plain_multiline[T, B](a: T, b: T) -> T: + return a + + +def arg_magic_multiline[T, B](a: T, b: T) -> T: + return a + + +def type_param_magic_multiline[T, B](a: T, b: T) -> T: + return a + + +def both_magic_multiline[T, B](a: T, b: T) -> T: + return a + + +def plain_mixed1[T, B](a: T, b: T) -> T: + return a + + +def plain_mixed2[T, B](a: T, b: T) -> T: + return a + + +def arg_magic_mixed1[T, B](a: T, b: T) -> T: + return a + + +def arg_magic_mixed2[T, B](a: T, b: T) -> T: + return a + + +def type_param_magic_mixed1[T, B](a: T, b: T) -> T: + return a + + +def type_param_magic_mixed2[T, B](a: T, b: T) -> T: + return a + + +def both_magic_mixed1[T, B](a: T, b: T) -> T: + return a + + +def both_magic_mixed2[T, B](a: T, b: T) -> T: + return a diff --git a/tests/data/cases/slices.py b/tests/data/cases/slices.py new file mode 100644 index 0000000..165117c --- /dev/null +++ b/tests/data/cases/slices.py @@ -0,0 +1,31 @@ +slice[a.b : c.d] +slice[d :: d + 1] +slice[d + 1 :: d] +slice[d::d] +slice[0] +slice[-1] +slice[:-1] +slice[::-1] +slice[:c, c - 1] +slice[c, c + 1, d::] +slice[ham[c::d] :: 1] +slice[ham[cheese**2 : -1] : 1 : 1, ham[1:2]] +slice[:-1:] +slice[lambda: None : lambda: None] +slice[lambda x, y, *args, really=2, **kwargs: None :, None::] +slice[1 or 2 : True and False] +slice[not so_simple : 1 < val <= 10] +slice[(1 for i in range(42)) : x] +slice[:: [i for i in range(42)]] + + +async def f(): + slice[await x : [i async for i in arange(42)] : 42] + + +# These are from PEP-8: +ham[1:9], ham[1:9:3], ham[:9:3], ham[1::3], ham[1:9:] +ham[lower:upper], ham[lower:upper:], ham[lower::step] +# ham[lower+offset : upper+offset] +ham[: upper_fn(x) : step_fn(x)], ham[:: step_fn(x)] +ham[lower + offset : upper + offset] diff --git a/tests/data/cases/split_delimiter_comments.py b/tests/data/cases/split_delimiter_comments.py new file mode 100644 index 0000000..ea29f7c --- /dev/null +++ b/tests/data/cases/split_delimiter_comments.py @@ -0,0 +1,51 @@ +a = ( + 1 + # type: ignore + 2 # type: ignore +) +a = ( + 1 # type: ignore + + 2 # type: ignore +) +bad_split3 = ( + "What if we have inline comments on " # First Comment + "each line of a bad split? In that " # Second Comment + "case, we should just leave it alone." # Third Comment +) +parametrize( + ( + {}, + {}, + ), + ( # foobar + {}, + {}, + ), +) + + + +# output +a = ( + 1 # type: ignore + + 2 # type: ignore +) +a = ( + 1 # type: ignore + + 2 # type: ignore +) +bad_split3 = ( + "What if we have inline comments on " # First Comment + "each line of a bad split? In that " # Second Comment + "case, we should just leave it alone." # Third Comment +) +parametrize( + ( + {}, + {}, + ), + ( # foobar + {}, + {}, + ), +) + diff --git a/tests/data/cases/standardize_type_comments.py b/tests/data/cases/standardize_type_comments.py new file mode 100644 index 0000000..0b3e63c --- /dev/null +++ b/tests/data/cases/standardize_type_comments.py @@ -0,0 +1,22 @@ +def foo( + a, #type:int + b, #type: str + c, # type: List[int] + d, # type: Dict[int, str] + e, # type: ignore + f, # type : ignore + g, # type : ignore +): + pass + +# output +def foo( + a, # type: int + b, # type: str + c, # type: List[int] + d, # type: Dict[int, str] + e, # type: ignore + f, # type : ignore + g, # type : ignore +): + pass diff --git a/tests/data/cases/starred_for_target.py b/tests/data/cases/starred_for_target.py new file mode 100644 index 0000000..13e5178 --- /dev/null +++ b/tests/data/cases/starred_for_target.py @@ -0,0 +1,28 @@ +# flags: --minimum-version=3.10 +for x in *a, *b: + print(x) + +for x in a, b, *c: + print(x) + +for x in *a, b, c: + print(x) + +for x in *a, b, *c: + print(x) + +async for x in *a, *b: + print(x) + +async for x in *a, b, *c: + print(x) + +async for x in a, b, *c: + print(x) + +async for x in ( + *loooooooooooooooooooooong, + very, + *loooooooooooooooooooooooooooooooooooooooooooooooong, +): + print(x) diff --git a/tests/data/cases/string_prefixes.py b/tests/data/cases/string_prefixes.py new file mode 100644 index 0000000..f86da69 --- /dev/null +++ b/tests/data/cases/string_prefixes.py @@ -0,0 +1,45 @@ +#!/usr/bin/env python3 + +name = "Łukasz" +(f"hello {name}", F"hello {name}") +(b"", B"") +(u"", U"") +(r"", R"") + +(rf"", fr"", Rf"", fR"", rF"", Fr"", RF"", FR"") +(rb"", br"", Rb"", bR"", rB"", Br"", RB"", BR"") + + +def docstring_singleline(): + R"""2020 was one hell of a year. The good news is that we were able to""" + + +def docstring_multiline(): + R""" + clear out all of the issues opened in that time :p + """ + + +# output + + +#!/usr/bin/env python3 + +name = "Łukasz" +(f"hello {name}", f"hello {name}") +(b"", b"") +("", "") +(r"", R"") + +(rf"", rf"", Rf"", Rf"", rf"", rf"", Rf"", Rf"") +(rb"", rb"", Rb"", Rb"", rb"", rb"", Rb"", Rb"") + + +def docstring_singleline(): + R"""2020 was one hell of a year. The good news is that we were able to""" + + +def docstring_multiline(): + R""" + clear out all of the issues opened in that time :p + """ diff --git a/tests/data/cases/stub.py b/tests/data/cases/stub.py new file mode 100644 index 0000000..f3828d5 --- /dev/null +++ b/tests/data/cases/stub.py @@ -0,0 +1,152 @@ +# flags: --pyi +X: int + +def f(): ... + + +class D: + ... + + +class C: + ... + +class B: + this_lack_of_newline_should_be_kept: int + def b(self) -> None: ... + + but_this_newline_should_also_be_kept: int + +class A: + attr: int + attr2: str + + def f(self) -> int: + ... + + def g(self) -> str: ... + + + +def g(): + ... + +def h(): ... + +if sys.version_info >= (3, 8): + class E: + def f(self): ... + class F: + + def f(self): ... + class G: ... + class H: ... +else: + class I: ... + class J: ... + def f(): ... + + class K: + def f(self): ... + def f(): ... + +class Nested: + class dirty: ... + class little: ... + class secret: + def who_has_to_know(self): ... + def verse(self): ... + +class Conditional: + def f(self): ... + if sys.version_info >= (3, 8): + def g(self): ... + else: + def g(self): ... + def h(self): ... + def i(self): ... + if sys.version_info >= (3, 8): + def j(self): ... + def k(self): ... + if sys.version_info >= (3, 8): + class A: ... + class B: ... + class C: + def l(self): ... + def m(self): ... + + +# output +X: int + +def f(): ... + +class D: ... +class C: ... + +class B: + this_lack_of_newline_should_be_kept: int + def b(self) -> None: ... + + but_this_newline_should_also_be_kept: int + +class A: + attr: int + attr2: str + + def f(self) -> int: ... + def g(self) -> str: ... + +def g(): ... +def h(): ... + +if sys.version_info >= (3, 8): + class E: + def f(self): ... + + class F: + def f(self): ... + + class G: ... + class H: ... + +else: + class I: ... + class J: ... + + def f(): ... + + class K: + def f(self): ... + + def f(): ... + +class Nested: + class dirty: ... + class little: ... + + class secret: + def who_has_to_know(self): ... + + def verse(self): ... + +class Conditional: + def f(self): ... + if sys.version_info >= (3, 8): + def g(self): ... + else: + def g(self): ... + + def h(self): ... + def i(self): ... + if sys.version_info >= (3, 8): + def j(self): ... + + def k(self): ... + if sys.version_info >= (3, 8): + class A: ... + class B: ... + + class C: + def l(self): ... + def m(self): ... diff --git a/tests/data/cases/target_version_flag.py b/tests/data/cases/target_version_flag.py new file mode 100644 index 0000000..5697281 --- /dev/null +++ b/tests/data/cases/target_version_flag.py @@ -0,0 +1,10 @@ +# flags: --minimum-version=3.12 --target-version=py312 +# this is invalid in versions below py312 +class ClassA[T: str]: + def method1(self) -> T: + ... + +# output +# this is invalid in versions below py312 +class ClassA[T: str]: + def method1(self) -> T: ... diff --git a/tests/data/cases/torture.py b/tests/data/cases/torture.py new file mode 100644 index 0000000..2a19475 --- /dev/null +++ b/tests/data/cases/torture.py @@ -0,0 +1,91 @@ +importA;() << 0 ** 101234234242352525425252352352525234890264906820496920680926538059059209922523523525 # + +assert sort_by_dependency( + { + "1": {"2", "3"}, "2": {"2a", "2b"}, "3": {"3a", "3b"}, + "2a": set(), "2b": set(), "3a": set(), "3b": set() + } +) == ["2a", "2b", "2", "3a", "3b", "3", "1"] + +importA +0;0^0# + +class A: + def foo(self): + for _ in range(10): + aaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbb.cccccccccc( # pylint: disable=no-member + xxxxxxxxxxxx + ) + +def test(self, othr): + return (1 == 2 and + (name, description, self.default, self.selected, self.auto_generated, self.parameters, self.meta_data, self.schedule) == + (name, description, othr.default, othr.selected, othr.auto_generated, othr.parameters, othr.meta_data, othr.schedule)) + + +assert ( + a_function(very_long_arguments_that_surpass_the_limit, which_is_eighty_eight_in_this_case_plus_a_bit_more) + == {"x": "this need to pass the line limit as well", "b": "but only by a little bit"} +) + +# output + +importA +( + () + << 0 + ** 101234234242352525425252352352525234890264906820496920680926538059059209922523523525 +) # + +assert sort_by_dependency( + { + "1": {"2", "3"}, + "2": {"2a", "2b"}, + "3": {"3a", "3b"}, + "2a": set(), + "2b": set(), + "3a": set(), + "3b": set(), + } +) == ["2a", "2b", "2", "3a", "3b", "3", "1"] + +importA +0 +0 ^ 0 # + + +class A: + def foo(self): + for _ in range(10): + aaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbb.cccccccccc( + xxxxxxxxxxxx + ) # pylint: disable=no-member + + +def test(self, othr): + return 1 == 2 and ( + name, + description, + self.default, + self.selected, + self.auto_generated, + self.parameters, + self.meta_data, + self.schedule, + ) == ( + name, + description, + othr.default, + othr.selected, + othr.auto_generated, + othr.parameters, + othr.meta_data, + othr.schedule, + ) + + +assert a_function( + very_long_arguments_that_surpass_the_limit, + which_is_eighty_eight_in_this_case_plus_a_bit_more, +) == {"x": "this need to pass the line limit as well", "b": "but only by a little bit"} + diff --git a/tests/data/cases/trailing_comma.py b/tests/data/cases/trailing_comma.py new file mode 100644 index 0000000..5b09c66 --- /dev/null +++ b/tests/data/cases/trailing_comma.py @@ -0,0 +1,55 @@ +e = { + "a": fun(msg, "ts"), + "longggggggggggggggid": ..., + "longgggggggggggggggggggkey": ..., "created": ... + # "longkey": ... +} +f = [ + arg1, + arg2, + arg3, arg4 + # comment +] +g = ( + arg1, + arg2, + arg3, arg4 + # comment +) +h = { + arg1, + arg2, + arg3, arg4 + # comment +} + +# output + +e = { + "a": fun(msg, "ts"), + "longggggggggggggggid": ..., + "longgggggggggggggggggggkey": ..., + "created": ..., + # "longkey": ... +} +f = [ + arg1, + arg2, + arg3, + arg4, + # comment +] +g = ( + arg1, + arg2, + arg3, + arg4, + # comment +) +h = { + arg1, + arg2, + arg3, + arg4, + # comment +} diff --git a/tests/data/cases/trailing_comma_optional_parens1.py b/tests/data/cases/trailing_comma_optional_parens1.py new file mode 100644 index 0000000..85aa8ba --- /dev/null +++ b/tests/data/cases/trailing_comma_optional_parens1.py @@ -0,0 +1,63 @@ +if e1234123412341234.winerror not in (_winapi.ERROR_SEM_TIMEOUT, + _winapi.ERROR_PIPE_BUSY) or _check_timeout(t): + pass + +if x: + if y: + new_id = max(Vegetable.objects.order_by('-id')[0].id, + Mineral.objects.order_by('-id')[0].id) + 1 + +class X: + def get_help_text(self): + return ngettext( + "Your password must contain at least %(min_length)d character.", + "Your password must contain at least %(min_length)d characters.", + self.min_length, + ) % {'min_length': self.min_length} + +class A: + def b(self): + if self.connection.mysql_is_mariadb and ( + 10, + 4, + 3, + ) < self.connection.mysql_version < (10, 5, 2): + pass + + +# output + +if e1234123412341234.winerror not in ( + _winapi.ERROR_SEM_TIMEOUT, + _winapi.ERROR_PIPE_BUSY, +) or _check_timeout(t): + pass + +if x: + if y: + new_id = ( + max( + Vegetable.objects.order_by("-id")[0].id, + Mineral.objects.order_by("-id")[0].id, + ) + + 1 + ) + + +class X: + def get_help_text(self): + return ngettext( + "Your password must contain at least %(min_length)d character.", + "Your password must contain at least %(min_length)d characters.", + self.min_length, + ) % {"min_length": self.min_length} + + +class A: + def b(self): + if self.connection.mysql_is_mariadb and ( + 10, + 4, + 3, + ) < self.connection.mysql_version < (10, 5, 2): + pass diff --git a/tests/data/cases/trailing_comma_optional_parens2.py b/tests/data/cases/trailing_comma_optional_parens2.py new file mode 100644 index 0000000..9541670 --- /dev/null +++ b/tests/data/cases/trailing_comma_optional_parens2.py @@ -0,0 +1,12 @@ +if (e123456.get_tk_patchlevel() >= (8, 6, 0, 'final') or + (8, 5, 8) <= get_tk_patchlevel() < (8, 6)): + pass + +# output + +if e123456.get_tk_patchlevel() >= (8, 6, 0, "final") or ( + 8, + 5, + 8, +) <= get_tk_patchlevel() < (8, 6): + pass diff --git a/tests/data/cases/trailing_comma_optional_parens3.py b/tests/data/cases/trailing_comma_optional_parens3.py new file mode 100644 index 0000000..c0ed699 --- /dev/null +++ b/tests/data/cases/trailing_comma_optional_parens3.py @@ -0,0 +1,21 @@ +if True: + if True: + if True: + return _( + "qweasdzxcqweasdzxcqweasdzxcqweasdzxcqweasdzxcqweasdzxcqweasdzxcqweasdzxcqweasdzxcqweas " + + "qweasdzxcqweasdzxcqweasdzxcqweasdzxcqweasdzxcqweasdzxcqweasdzxcqweasdzxcqwegqweasdzxcqweasdzxc.", + "qweasdzxcqweasdzxcqweasdzxcqweasdzxcqweasdzxcqweasdzxcqweasdzxcqweasdzxcqweasdzxcqwe", + ) % {"reported_username": reported_username, "report_reason": report_reason} + + +# output + + +if True: + if True: + if True: + return _( + "qweasdzxcqweasdzxcqweasdzxcqweasdzxcqweasdzxcqweasdzxcqweasdzxcqweasdzxcqweasdzxcqweas " + + "qweasdzxcqweasdzxcqweasdzxcqweasdzxcqweasdzxcqweasdzxcqweasdzxcqweasdzxcqwegqweasdzxcqweasdzxc.", + "qweasdzxcqweasdzxcqweasdzxcqweasdzxcqweasdzxcqweasdzxcqweasdzxcqweasdzxcqweasdzxcqwe", + ) % {"reported_username": reported_username, "report_reason": report_reason} diff --git a/tests/data/cases/trailing_commas_in_leading_parts.py b/tests/data/cases/trailing_commas_in_leading_parts.py new file mode 100644 index 0000000..99d82a6 --- /dev/null +++ b/tests/data/cases/trailing_commas_in_leading_parts.py @@ -0,0 +1,88 @@ +zero(one,).two(three,).four(five,) + +func1(arg1).func2(arg2,).func3(arg3).func4(arg4,).func5(arg5) + +# Inner one-element tuple shouldn't explode +func1(arg1).func2(arg1, (one_tuple,)).func3(arg3) + +(a, b, c, d,) = func1(arg1) and func2(arg2) + + +# Example from https://github.com/psf/black/issues/3229 +def refresh_token(self, device_family, refresh_token, api_key): + return self.orchestration.refresh_token( + data={ + "refreshToken": refresh_token, + }, + api_key=api_key, + )["extensions"]["sdk"]["token"] + + +# Edge case where a bug in a working-in-progress version of +# https://github.com/psf/black/pull/3370 causes an infinite recursion. +assert ( + long_module.long_class.long_func().another_func() + == long_module.long_class.long_func()["some_key"].another_func(arg1) +) + +# Regression test for https://github.com/psf/black/issues/3414. +assert xxxxxxxxx.xxxxxxxxx.xxxxxxxxx( + xxxxxxxxx +).xxxxxxxxxxxxxxxxxx(), ( + "xxx {xxxxxxxxx} xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +) + + +# output + + +zero( + one, +).two( + three, +).four( + five, +) + +func1(arg1).func2( + arg2, +).func3(arg3).func4( + arg4, +).func5(arg5) + +# Inner one-element tuple shouldn't explode +func1(arg1).func2(arg1, (one_tuple,)).func3(arg3) + +( + a, + b, + c, + d, +) = func1( + arg1 +) and func2(arg2) + + +# Example from https://github.com/psf/black/issues/3229 +def refresh_token(self, device_family, refresh_token, api_key): + return self.orchestration.refresh_token( + data={ + "refreshToken": refresh_token, + }, + api_key=api_key, + )["extensions"]["sdk"]["token"] + + +# Edge case where a bug in a working-in-progress version of +# https://github.com/psf/black/pull/3370 causes an infinite recursion. +assert ( + long_module.long_class.long_func().another_func() + == long_module.long_class.long_func()["some_key"].another_func(arg1) +) + +# Regression test for https://github.com/psf/black/issues/3414. +assert xxxxxxxxx.xxxxxxxxx.xxxxxxxxx( + xxxxxxxxx +).xxxxxxxxxxxxxxxxxx(), ( + "xxx {xxxxxxxxx} xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +) diff --git a/tests/data/cases/tricky_unicode_symbols.py b/tests/data/cases/tricky_unicode_symbols.py new file mode 100644 index 0000000..ad8b610 --- /dev/null +++ b/tests/data/cases/tricky_unicode_symbols.py @@ -0,0 +1,9 @@ +ä = 1 +µ = 2 +蟒 = 3 +x󠄀 = 4 +មុ = 1 +Q̇_per_meter = 4 + +A᧚ = 3 +A፩ = 8 diff --git a/tests/data/cases/tuple_with_stmt.py b/tests/data/cases/tuple_with_stmt.py new file mode 100644 index 0000000..885a300 --- /dev/null +++ b/tests/data/cases/tuple_with_stmt.py @@ -0,0 +1,30 @@ +# don't remove the brackets here, it changes the meaning of the code. +# even though the code will always trigger a runtime error +with (name_5, name_4), name_5: + pass + + +with c, (a, b): + pass + + +with c, (a, b), d: + pass + + +with c, (a, b, e, f, g), d: + pass + + +def test_tuple_as_contextmanager(): + from contextlib import nullcontext + + try: + with (nullcontext(), nullcontext()), nullcontext(): + pass + except TypeError: + # test passed + pass + else: + # this should be a type error + assert False diff --git a/tests/data/cases/tupleassign.py b/tests/data/cases/tupleassign.py new file mode 100644 index 0000000..d948fee --- /dev/null +++ b/tests/data/cases/tupleassign.py @@ -0,0 +1,23 @@ +# This is a standalone comment. +sdfjklsdfsjldkflkjsf, sdfjsdfjlksdljkfsdlkf, sdfsdjfklsdfjlksdljkf, sdsfsdfjskdflsfsdf = 1, 2, 3 + +# This is as well. +this_will_be_wrapped_in_parens, = struct.unpack(b"12345678901234567890") + +(a,) = call() + +# output + + +# This is a standalone comment. +( + sdfjklsdfsjldkflkjsf, + sdfjsdfjlksdljkfsdlkf, + sdfsdjfklsdfjlksdljkf, + sdsfsdfjskdflsfsdf, +) = (1, 2, 3) + +# This is as well. +(this_will_be_wrapped_in_parens,) = struct.unpack(b"12345678901234567890") + +(a,) = call() \ No newline at end of file diff --git a/tests/data/cases/type_aliases.py b/tests/data/cases/type_aliases.py new file mode 100644 index 0000000..7c2009e --- /dev/null +++ b/tests/data/cases/type_aliases.py @@ -0,0 +1,30 @@ +# flags: --minimum-version=3.12 + +type A=int +type Gen[T]=list[T] +type Alias[T]=lambda: T +type And[T]=T and T +type IfElse[T]=T if T else T +type One = int; type Another = str +class X: type InClass = int + +type = aliased +print(type(42)) + +# output + +type A = int +type Gen[T] = list[T] +type Alias[T] = lambda: T +type And[T] = T and T +type IfElse[T] = T if T else T +type One = int +type Another = str + + +class X: + type InClass = int + + +type = aliased +print(type(42)) diff --git a/tests/data/cases/type_comment_syntax_error.py b/tests/data/cases/type_comment_syntax_error.py new file mode 100644 index 0000000..2e5ca2e --- /dev/null +++ b/tests/data/cases/type_comment_syntax_error.py @@ -0,0 +1,11 @@ +def foo( + # type: Foo + x): pass + +# output + +def foo( + # type: Foo + x, +): + pass diff --git a/tests/data/cases/type_expansion.py b/tests/data/cases/type_expansion.py new file mode 100644 index 0000000..d5cbc6e --- /dev/null +++ b/tests/data/cases/type_expansion.py @@ -0,0 +1,60 @@ +# flags: --minimum-version=3.12 + +def f1[T: (int, str)](a,): pass + +def f2[T: (int, str)](a: int, b,): pass + +def g1[T: (int,)](a,): pass + +def g2[T: (int, str, bytes)](a,): pass + +def g3[T: ((int, str), (bytes,))](a,): pass + +def g4[T: (int, (str, bytes))](a,): pass + +def g5[T: ((int,),)](a: int, b,): pass + +# output + +def f1[T: (int, str)]( + a, +): + pass + + +def f2[T: (int, str)]( + a: int, + b, +): + pass + + +def g1[T: (int,)]( + a, +): + pass + + +def g2[T: (int, str, bytes)]( + a, +): + pass + + +def g3[T: ((int, str), (bytes,))]( + a, +): + pass + + +def g4[T: (int, (str, bytes))]( + a, +): + pass + + +def g5[T: ((int,),)]( + a: int, + b, +): + pass diff --git a/tests/data/cases/type_ignore_with_other_comment.py b/tests/data/cases/type_ignore_with_other_comment.py new file mode 100644 index 0000000..bfa330d --- /dev/null +++ b/tests/data/cases/type_ignore_with_other_comment.py @@ -0,0 +1,27 @@ +import pandas as pd + +interval_td = pd.Interval( + pd.Timedelta("1 days"), pd.Timedelta("2 days"), closed="neither" +) + +_td = ( # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + interval_td + - pd.Interval( # type: ignore[operator] + pd.Timedelta(1, "ns"), pd.Timedelta(2, "ns") + ) +) + +# output + +import pandas as pd + +interval_td = pd.Interval( + pd.Timedelta("1 days"), pd.Timedelta("2 days"), closed="neither" +) + +_td = ( # pyright: ignore[reportOperatorIssue,reportUnknownVariableType] + interval_td + - pd.Interval( # type: ignore[operator] + pd.Timedelta(1, "ns"), pd.Timedelta(2, "ns") + ) +) diff --git a/tests/data/cases/type_param_defaults.py b/tests/data/cases/type_param_defaults.py new file mode 100644 index 0000000..f8c24eb --- /dev/null +++ b/tests/data/cases/type_param_defaults.py @@ -0,0 +1,69 @@ +# flags: --minimum-version=3.13 + +type A[T=int] = float +type B[*P=int] = float +type C[*Ts=int] = float +type D[*Ts=*int] = float +type D[something_that_is_very_very_very_long=something_that_is_very_very_very_long] = float +type D[*something_that_is_very_very_very_long=*something_that_is_very_very_very_long] = float +type something_that_is_long[something_that_is_long=something_that_is_long] = something_that_is_long + +def simple[T=something_that_is_long](short1: int, short2: str, short3: bytes) -> float: + pass + +def longer[something_that_is_long=something_that_is_long](something_that_is_long: something_that_is_long) -> something_that_is_long: + pass + +def trailing_comma1[T=int,](a: str): + pass + +def trailing_comma2[T=int](a: str,): + pass + +def weird_syntax[T=lambda: 42, **P=lambda: 43, *Ts=lambda: 44](): pass + +# output + +type A[T = int] = float +type B[*P = int] = float +type C[*Ts = int] = float +type D[*Ts = *int] = float +type D[ + something_that_is_very_very_very_long = something_that_is_very_very_very_long +] = float +type D[ + *something_that_is_very_very_very_long = *something_that_is_very_very_very_long +] = float +type something_that_is_long[ + something_that_is_long = something_that_is_long +] = something_that_is_long + + +def simple[T = something_that_is_long]( + short1: int, short2: str, short3: bytes +) -> float: + pass + + +def longer[something_that_is_long = something_that_is_long]( + something_that_is_long: something_that_is_long, +) -> something_that_is_long: + pass + + +def trailing_comma1[ + T = int, +]( + a: str, +): + pass + + +def trailing_comma2[T = int]( + a: str, +): + pass + + +def weird_syntax[T = lambda: 42, **P = lambda: 43, *Ts = lambda: 44](): + pass diff --git a/tests/data/cases/type_params.py b/tests/data/cases/type_params.py new file mode 100644 index 0000000..124292d --- /dev/null +++ b/tests/data/cases/type_params.py @@ -0,0 +1,72 @@ +# flags: --minimum-version=3.12 +def func [T ](): pass +async def func [ T ] (): pass +class C[ T ] : pass + +def all_in[T : int,U : (bytes, str),* Ts,**P](): pass + +def really_long[WhatIsTheLongestTypeVarNameYouCanThinkOfEnoughToMakeBlackSplitThisLine](): pass + +def even_longer[WhatIsTheLongestTypeVarNameYouCanThinkOfEnoughToMakeBlackSplitThisLine: WhatIfItHadABound](): pass + +def it_gets_worse[WhatIsTheLongestTypeVarNameYouCanThinkOfEnoughToMakeBlackSplitThisLine, ItCouldBeGenericOverMultipleTypeVars](): pass + +def magic[Trailing, Comma,](): pass + +def weird_syntax[T: lambda: 42, U: a or b](): pass + +def name_3[name_0: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa if aaaaaaaaaaa else name_3](): pass + +# output + + +def func[T](): + pass + + +async def func[T](): + pass + + +class C[T]: + pass + + +def all_in[T: int, U: (bytes, str), *Ts, **P](): + pass + + +def really_long[ + WhatIsTheLongestTypeVarNameYouCanThinkOfEnoughToMakeBlackSplitThisLine +](): + pass + + +def even_longer[ + WhatIsTheLongestTypeVarNameYouCanThinkOfEnoughToMakeBlackSplitThisLine: WhatIfItHadABound +](): + pass + + +def it_gets_worse[ + WhatIsTheLongestTypeVarNameYouCanThinkOfEnoughToMakeBlackSplitThisLine, + ItCouldBeGenericOverMultipleTypeVars, +](): + pass + + +def magic[ + Trailing, + Comma, +](): + pass + + +def weird_syntax[T: lambda: 42, U: a or b](): + pass + + +def name_3[ + name_0: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa if aaaaaaaaaaa else name_3 +](): + pass diff --git a/tests/data/cases/typed_params_trailing_comma.py b/tests/data/cases/typed_params_trailing_comma.py new file mode 100644 index 0000000..5bcdb94 --- /dev/null +++ b/tests/data/cases/typed_params_trailing_comma.py @@ -0,0 +1,23 @@ +def long_function_name_goes_here( + x: Callable[List[int]] +) -> Union[List[int], float, str, bytes, Tuple[int]]: + pass + + +def long_function_name_goes_here( + x: Callable[[str, Any], int] +) -> Union[List[int], float, str, bytes, Tuple[int]]: + pass + + +# output +def long_function_name_goes_here( + x: Callable[List[int]], +) -> Union[List[int], float, str, bytes, Tuple[int]]: + pass + + +def long_function_name_goes_here( + x: Callable[[str, Any], int], +) -> Union[List[int], float, str, bytes, Tuple[int]]: + pass diff --git a/tests/data/cases/walrus_in_dict.py b/tests/data/cases/walrus_in_dict.py new file mode 100644 index 0000000..33af6ab --- /dev/null +++ b/tests/data/cases/walrus_in_dict.py @@ -0,0 +1,6 @@ +{ + "is_update": (up := commit.hash in update_hashes) +} + +# output +{"is_update": (up := commit.hash in update_hashes)} diff --git a/tests/data/cases/whitespace.py b/tests/data/cases/whitespace.py new file mode 100644 index 0000000..a319c01 --- /dev/null +++ b/tests/data/cases/whitespace.py @@ -0,0 +1,6 @@ + + + + + +# output diff --git a/tests/data/cases/yield_singleton_tuple.py b/tests/data/cases/yield_singleton_tuple.py new file mode 100644 index 0000000..c357c01 --- /dev/null +++ b/tests/data/cases/yield_singleton_tuple.py @@ -0,0 +1,11 @@ +# flags: --preview + +def f(): + yield x, + + +# output + + +def f(): + yield (x,) diff --git a/tests/data/cases/yield_singleton_tuple_stable.py b/tests/data/cases/yield_singleton_tuple_stable.py new file mode 100644 index 0000000..8acbf3d --- /dev/null +++ b/tests/data/cases/yield_singleton_tuple_stable.py @@ -0,0 +1,9 @@ +def f(): + yield x, + + +# output + + +def f(): + yield x, diff --git a/tests/data/empty_pyproject.toml b/tests/data/empty_pyproject.toml new file mode 100644 index 0000000..8c5274d --- /dev/null +++ b/tests/data/empty_pyproject.toml @@ -0,0 +1,2 @@ +# Empty pyproject.toml to use with some tests that depend on Python 3.6 autodiscovery +# and so on. diff --git a/tests/data/gitignore_used_on_multiple_sources/.gitignore b/tests/data/gitignore_used_on_multiple_sources/.gitignore new file mode 100644 index 0000000..2987e7b --- /dev/null +++ b/tests/data/gitignore_used_on_multiple_sources/.gitignore @@ -0,0 +1 @@ +a.py diff --git a/tests/data/gitignore_used_on_multiple_sources/dir1/b.py b/tests/data/gitignore_used_on_multiple_sources/dir1/b.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/data/gitignore_used_on_multiple_sources/dir2/b.py b/tests/data/gitignore_used_on_multiple_sources/dir2/b.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/data/ignore_directory_gitignore_tests/.gitignore b/tests/data/ignore_directory_gitignore_tests/.gitignore new file mode 100644 index 0000000..4573ac5 --- /dev/null +++ b/tests/data/ignore_directory_gitignore_tests/.gitignore @@ -0,0 +1,3 @@ +large_ignored_dir/ +large_ignored_dir_two +abc.py diff --git a/tests/data/ignore_directory_gitignore_tests/z.py b/tests/data/ignore_directory_gitignore_tests/z.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/data/ignore_subfolders_gitignore_tests/a.py b/tests/data/ignore_subfolders_gitignore_tests/a.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/data/ignore_subfolders_gitignore_tests/subdir/.gitignore b/tests/data/ignore_subfolders_gitignore_tests/subdir/.gitignore new file mode 100644 index 0000000..150f68c --- /dev/null +++ b/tests/data/ignore_subfolders_gitignore_tests/subdir/.gitignore @@ -0,0 +1 @@ +*/* diff --git a/tests/data/ignore_subfolders_gitignore_tests/subdir/b.py b/tests/data/ignore_subfolders_gitignore_tests/subdir/b.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/data/include_exclude_tests/.gitignore b/tests/data/include_exclude_tests/.gitignore new file mode 100644 index 0000000..91f3456 --- /dev/null +++ b/tests/data/include_exclude_tests/.gitignore @@ -0,0 +1 @@ +dont_exclude/ diff --git a/tests/data/include_exclude_tests/b/.definitely_exclude/a.pie b/tests/data/include_exclude_tests/b/.definitely_exclude/a.pie new file mode 100644 index 0000000..e69de29 diff --git a/tests/data/include_exclude_tests/b/.definitely_exclude/a.py b/tests/data/include_exclude_tests/b/.definitely_exclude/a.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/data/include_exclude_tests/b/.definitely_exclude/a.pyi b/tests/data/include_exclude_tests/b/.definitely_exclude/a.pyi new file mode 100644 index 0000000..e69de29 diff --git a/tests/data/include_exclude_tests/b/exclude/a.pie b/tests/data/include_exclude_tests/b/exclude/a.pie new file mode 100644 index 0000000..e69de29 diff --git a/tests/data/include_exclude_tests/b/exclude/a.py b/tests/data/include_exclude_tests/b/exclude/a.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/data/include_exclude_tests/b/exclude/a.pyi b/tests/data/include_exclude_tests/b/exclude/a.pyi new file mode 100644 index 0000000..e69de29 diff --git a/tests/data/include_exclude_tests/b/exclude/still_exclude/a.pie b/tests/data/include_exclude_tests/b/exclude/still_exclude/a.pie new file mode 100644 index 0000000..e69de29 diff --git a/tests/data/include_exclude_tests/b/exclude/still_exclude/a.py b/tests/data/include_exclude_tests/b/exclude/still_exclude/a.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/data/include_exclude_tests/b/exclude/still_exclude/a.pyi b/tests/data/include_exclude_tests/b/exclude/still_exclude/a.pyi new file mode 100644 index 0000000..e69de29 diff --git a/tests/data/include_exclude_tests/pyproject.toml b/tests/data/include_exclude_tests/pyproject.toml new file mode 100644 index 0000000..9ba7ec2 --- /dev/null +++ b/tests/data/include_exclude_tests/pyproject.toml @@ -0,0 +1,3 @@ +[build-system] +requires = ["setuptools>=41.0", "setuptools-scm", "wheel"] +build-backend = "setuptools.build_meta" diff --git a/tests/data/incorrect_spelling.toml b/tests/data/incorrect_spelling.toml new file mode 100644 index 0000000..560c9e2 --- /dev/null +++ b/tests/data/incorrect_spelling.toml @@ -0,0 +1,5 @@ +[tool.black] +ine_length = 50 +target-ersion = ['py37'] +exclude='\.pyi?$' +include='\.py?$' \ No newline at end of file diff --git a/tests/data/invalid_gitignore_tests/.gitignore b/tests/data/invalid_gitignore_tests/.gitignore new file mode 100644 index 0000000..cdf4cb4 --- /dev/null +++ b/tests/data/invalid_gitignore_tests/.gitignore @@ -0,0 +1 @@ +! diff --git a/tests/data/invalid_gitignore_tests/a.py b/tests/data/invalid_gitignore_tests/a.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/data/invalid_gitignore_tests/pyproject.toml b/tests/data/invalid_gitignore_tests/pyproject.toml new file mode 100644 index 0000000..3908e45 --- /dev/null +++ b/tests/data/invalid_gitignore_tests/pyproject.toml @@ -0,0 +1 @@ +# Empty configuration file; used in tests to avoid interference from Black's own config. diff --git a/tests/data/invalid_line_ranges.toml b/tests/data/invalid_line_ranges.toml new file mode 100644 index 0000000..791573f --- /dev/null +++ b/tests/data/invalid_line_ranges.toml @@ -0,0 +1,2 @@ +[tool.black] +line-ranges = "1-1" diff --git a/tests/data/invalid_nested_gitignore_tests/a.py b/tests/data/invalid_nested_gitignore_tests/a.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/data/invalid_nested_gitignore_tests/a/.gitignore b/tests/data/invalid_nested_gitignore_tests/a/.gitignore new file mode 100644 index 0000000..cdf4cb4 --- /dev/null +++ b/tests/data/invalid_nested_gitignore_tests/a/.gitignore @@ -0,0 +1 @@ +! diff --git a/tests/data/invalid_nested_gitignore_tests/a/a.py b/tests/data/invalid_nested_gitignore_tests/a/a.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/data/invalid_nested_gitignore_tests/pyproject.toml b/tests/data/invalid_nested_gitignore_tests/pyproject.toml new file mode 100644 index 0000000..3908e45 --- /dev/null +++ b/tests/data/invalid_nested_gitignore_tests/pyproject.toml @@ -0,0 +1 @@ +# Empty configuration file; used in tests to avoid interference from Black's own config. diff --git a/tests/data/jupyter/non_python_notebook.ipynb b/tests/data/jupyter/non_python_notebook.ipynb new file mode 100644 index 0000000..da5cdd8 --- /dev/null +++ b/tests/data/jupyter/non_python_notebook.ipynb @@ -0,0 +1 @@ +{"metadata":{"kernelspec":{"name":"ir","display_name":"R","language":"R"},"language_info":{"name":"R","codemirror_mode":"r","pygments_lexer":"r","mimetype":"text/x-r-source","file_extension":".r","version":"4.0.5"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"library(tidyverse) ","metadata":{"_uuid":"051d70d956493feee0c6d64651c6a088724dca2a","_execution_state":"idle"},"execution_count":null,"outputs":[]}]} \ No newline at end of file diff --git a/tests/data/jupyter/notebook_empty_metadata.ipynb b/tests/data/jupyter/notebook_empty_metadata.ipynb new file mode 100644 index 0000000..7dc1f80 --- /dev/null +++ b/tests/data/jupyter/notebook_empty_metadata.ipynb @@ -0,0 +1,27 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "%%time\n", + "\n", + "print('foo')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": {}, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tests/data/jupyter/notebook_no_trailing_newline.ipynb b/tests/data/jupyter/notebook_no_trailing_newline.ipynb new file mode 100644 index 0000000..79f95be --- /dev/null +++ b/tests/data/jupyter/notebook_no_trailing_newline.ipynb @@ -0,0 +1,39 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "%%time\n", + "\n", + "print('foo')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "interpreter": { + "hash": "e758f3098b5b55f4d87fe30bbdc1367f20f246b483f96267ee70e6c40cb185d8" + }, + "kernelspec": { + "display_name": "Python 3.8.10 64-bit ('black': venv)", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} \ No newline at end of file diff --git a/tests/data/jupyter/notebook_trailing_newline.ipynb b/tests/data/jupyter/notebook_trailing_newline.ipynb new file mode 100644 index 0000000..4f82869 --- /dev/null +++ b/tests/data/jupyter/notebook_trailing_newline.ipynb @@ -0,0 +1,39 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "%%time\n", + "\n", + "print('foo')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "interpreter": { + "hash": "e758f3098b5b55f4d87fe30bbdc1367f20f246b483f96267ee70e6c40cb185d8" + }, + "kernelspec": { + "display_name": "Python 3.8.10 64-bit ('black': venv)", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tests/data/jupyter/notebook_which_cant_be_parsed.ipynb b/tests/data/jupyter/notebook_which_cant_be_parsed.ipynb new file mode 100644 index 0000000..257cc56 --- /dev/null +++ b/tests/data/jupyter/notebook_which_cant_be_parsed.ipynb @@ -0,0 +1 @@ +foo diff --git a/tests/data/jupyter/notebook_without_changes.ipynb b/tests/data/jupyter/notebook_without_changes.ipynb new file mode 100644 index 0000000..ac6c7e6 --- /dev/null +++ b/tests/data/jupyter/notebook_without_changes.ipynb @@ -0,0 +1,46 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "%%time\n", + "\n", + "print(\"foo\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook should not be reformatted" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "interpreter": { + "hash": "e758f3098b5b55f4d87fe30bbdc1367f20f246b483f96267ee70e6c40cb185d8" + }, + "kernelspec": { + "display_name": "Python 3.8.10 64-bit ('black': venv)", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} \ No newline at end of file diff --git a/tests/data/line_ranges_formatted/basic.py b/tests/data/line_ranges_formatted/basic.py new file mode 100644 index 0000000..9d5567d --- /dev/null +++ b/tests/data/line_ranges_formatted/basic.py @@ -0,0 +1,49 @@ +"""Module doc.""" + +from typing import ( + Callable, + Literal, +) + +# fmt: off +class Unformatted: + def should_also_work(self): + pass +# fmt: on + + +a = [1, 2] # fmt: skip + + +# This should cover as many syntaxes as possible. +class Foo: + """Class doc.""" + + def __init__(self) -> None: + pass + + @add_logging + @memoize.memoize(max_items=2) + def plus_one( + self, + number: int, + ) -> int: + return number + 1 + + async def async_plus_one(self, number: int) -> int: + await asyncio.sleep(1) + async with some_context(): + return number + 1 + + +try: + for i in range(10): + while condition: + if something: + then_something() + elif something_else: + then_something_else() +except ValueError as e: + handle(e) +finally: + done() diff --git a/tests/data/line_ranges_formatted/pattern_matching.py b/tests/data/line_ranges_formatted/pattern_matching.py new file mode 100644 index 0000000..cd98efd --- /dev/null +++ b/tests/data/line_ranges_formatted/pattern_matching.py @@ -0,0 +1,25 @@ +# flags: --minimum-version=3.10 + + +def pattern_matching(): + match status: + case 1: + return "1" + case [single]: + return "single" + case [ + action, + obj, + ]: + return "act on obj" + case Point(x=0): + return "class pattern" + case {"text": message}: + return "mapping" + case { + "text": message, + "format": _, + }: + return "mapping" + case _: + return "fallback" diff --git a/tests/data/miscellaneous/async_as_identifier.py b/tests/data/miscellaneous/async_as_identifier.py new file mode 100644 index 0000000..c36a5e5 --- /dev/null +++ b/tests/data/miscellaneous/async_as_identifier.py @@ -0,0 +1,49 @@ +def async(): + pass + + +def await(): + pass + + +await = lambda: None +async = lambda: None +async() +await() + + +def sync_fn(): + await = lambda: None + async = lambda: None + async() + await() + + +async def async_fn(): + await async_fn() + + +# output +def async(): + pass + + +def await(): + pass + + +await = lambda: None +async = lambda: None +async() +await() + + +def sync_fn(): + await = lambda: None + async = lambda: None + async() + await() + + +async def async_fn(): + await async_fn() diff --git a/tests/data/miscellaneous/blackd_diff.diff b/tests/data/miscellaneous/blackd_diff.diff new file mode 100644 index 0000000..6226858 --- /dev/null +++ b/tests/data/miscellaneous/blackd_diff.diff @@ -0,0 +1,13 @@ +--- [Deterministic header] ++++ [Deterministic header] +@@ -1,6 +1,5 @@ +-def abc (): +- return ["hello", "world", +- "!"] ++def abc(): ++ return ["hello", "world", "!"] + +-print( "Incorrect formatting" +-) ++ ++print("Incorrect formatting") diff --git a/tests/data/miscellaneous/blackd_diff.py b/tests/data/miscellaneous/blackd_diff.py new file mode 100644 index 0000000..c527832 --- /dev/null +++ b/tests/data/miscellaneous/blackd_diff.py @@ -0,0 +1,6 @@ +def abc (): + return ["hello", "world", + "!"] + +print( "Incorrect formatting" +) diff --git a/tests/data/miscellaneous/debug_visitor.out b/tests/data/miscellaneous/debug_visitor.out new file mode 100644 index 0000000..a243ab7 --- /dev/null +++ b/tests/data/miscellaneous/debug_visitor.out @@ -0,0 +1,924 @@ +file_input + decorated + decorator + AT + '@' + NAME + 'dataclass' + NEWLINE + '\n' + /decorator + classdef + NAME + 'class' + NAME + ' ' + 'DebugVisitor' + LPAR + '(' + power + NAME + 'Visitor' + trailer + LSQB + '[' + NAME + 'T' + RSQB + ']' + /trailer + /power + RPAR + ')' + COLON + ':' + suite + NEWLINE + '\n' + INDENT + '' + simple_stmt + expr_stmt + NAME + ' ' + 'tree_depth' + annassign + COLON + ':' + NAME + ' ' + 'int' + EQUAL + ' ' + '=' + NUMBER + ' ' + '0' + /annassign + /expr_stmt + NEWLINE + '\n' + /simple_stmt + funcdef + NAME + '\n ' + 'def' + NAME + ' ' + 'visit_default' + parameters + LPAR + '(' + typedargslist + NAME + 'self' + COMMA + ',' + tname + NAME + ' ' + 'node' + COLON + ':' + NAME + ' ' + 'LN' + /tname + /typedargslist + RPAR + ')' + /parameters + RARROW + ' ' + '->' + power + NAME + ' ' + 'Iterator' + trailer + LSQB + '[' + NAME + 'T' + RSQB + ']' + /trailer + /power + COLON + ':' + suite + NEWLINE + '\n' + INDENT + '' + simple_stmt + expr_stmt + NAME + ' ' + 'indent' + EQUAL + ' ' + '=' + term + STRING + ' ' + "' '" + STAR + ' ' + '*' + atom + LPAR + ' ' + '(' + term + NUMBER + '2' + STAR + ' ' + '*' + power + NAME + ' ' + 'self' + trailer + DOT + '.' + NAME + 'tree_depth' + /trailer + /power + /term + RPAR + ')' + /atom + /term + /expr_stmt + NEWLINE + '\n' + /simple_stmt + if_stmt + NAME + ' ' + 'if' + power + NAME + ' ' + 'isinstance' + trailer + LPAR + '(' + arglist + NAME + 'node' + COMMA + ',' + NAME + ' ' + 'Node' + /arglist + RPAR + ')' + /trailer + /power + COLON + ':' + suite + NEWLINE + '\n' + INDENT + '' + simple_stmt + expr_stmt + NAME + ' ' + '_type' + EQUAL + ' ' + '=' + power + NAME + ' ' + 'type_repr' + trailer + LPAR + '(' + power + NAME + 'node' + trailer + DOT + '.' + NAME + 'type' + /trailer + /power + RPAR + ')' + /trailer + /power + /expr_stmt + NEWLINE + '\n' + /simple_stmt + simple_stmt + power + NAME + ' ' + 'out' + trailer + LPAR + '(' + arglist + fstring + FSTRING_START + "f'" + fstring_replacement_field + LBRACE + '{' + NAME + 'indent' + RBRACE + '}' + /fstring_replacement_field + fstring_replacement_field + LBRACE + '{' + NAME + '_type' + RBRACE + '}' + /fstring_replacement_field + FSTRING_END + "'" + /fstring + COMMA + ',' + argument + NAME + ' ' + 'fg' + EQUAL + '=' + STRING + "'yellow'" + /argument + /arglist + RPAR + ')' + /trailer + /power + NEWLINE + '\n' + /simple_stmt + simple_stmt + expr_stmt + power + NAME + ' ' + 'self' + trailer + DOT + '.' + NAME + 'tree_depth' + /trailer + /power + PLUSEQUAL + ' ' + '+=' + NUMBER + ' ' + '1' + /expr_stmt + NEWLINE + '\n' + /simple_stmt + for_stmt + NAME + ' ' + 'for' + NAME + ' ' + 'child' + NAME + ' ' + 'in' + power + NAME + ' ' + 'node' + trailer + DOT + '.' + NAME + 'children' + /trailer + /power + COLON + ':' + suite + NEWLINE + '\n' + INDENT + '' + simple_stmt + yield_expr + NAME + ' ' + 'yield' + yield_arg + NAME + ' ' + 'from' + power + NAME + ' ' + 'self' + trailer + DOT + '.' + NAME + 'visit' + /trailer + trailer + LPAR + '(' + NAME + 'child' + RPAR + ')' + /trailer + /power + /yield_arg + /yield_expr + NEWLINE + '\n' + /simple_stmt + DEDENT + '' + /suite + /for_stmt + simple_stmt + expr_stmt + power + NAME + '\n ' + 'self' + trailer + DOT + '.' + NAME + 'tree_depth' + /trailer + /power + MINEQUAL + ' ' + '-=' + NUMBER + ' ' + '1' + /expr_stmt + NEWLINE + '\n' + /simple_stmt + simple_stmt + power + NAME + ' ' + 'out' + trailer + LPAR + '(' + arglist + fstring + FSTRING_START + "f'" + fstring_replacement_field + LBRACE + '{' + NAME + 'indent' + RBRACE + '}' + /fstring_replacement_field + FSTRING_MIDDLE + '/' + fstring_replacement_field + LBRACE + '{' + NAME + '_type' + RBRACE + '}' + /fstring_replacement_field + FSTRING_END + "'" + /fstring + COMMA + ',' + argument + NAME + ' ' + 'fg' + EQUAL + '=' + STRING + "'yellow'" + /argument + COMMA + ',' + argument + NAME + ' ' + 'bold' + EQUAL + '=' + NAME + 'False' + /argument + /arglist + RPAR + ')' + /trailer + /power + NEWLINE + '\n' + /simple_stmt + DEDENT + '' + /suite + NAME + ' ' + 'else' + COLON + ':' + suite + NEWLINE + '\n' + INDENT + '' + simple_stmt + expr_stmt + NAME + ' ' + '_type' + EQUAL + ' ' + '=' + power + NAME + ' ' + 'token' + trailer + DOT + '.' + NAME + 'tok_name' + /trailer + trailer + DOT + '.' + NAME + 'get' + /trailer + trailer + LPAR + '(' + arglist + power + NAME + 'node' + trailer + DOT + '.' + NAME + 'type' + /trailer + /power + COMMA + ',' + power + NAME + ' ' + 'str' + trailer + LPAR + '(' + power + NAME + 'node' + trailer + DOT + '.' + NAME + 'type' + /trailer + /power + RPAR + ')' + /trailer + /power + /arglist + RPAR + ')' + /trailer + /power + /expr_stmt + NEWLINE + '\n' + /simple_stmt + simple_stmt + power + NAME + ' ' + 'out' + trailer + LPAR + '(' + arglist + fstring + FSTRING_START + "f'" + fstring_replacement_field + LBRACE + '{' + NAME + 'indent' + RBRACE + '}' + /fstring_replacement_field + fstring_replacement_field + LBRACE + '{' + NAME + '_type' + RBRACE + '}' + /fstring_replacement_field + FSTRING_END + "'" + /fstring + COMMA + ',' + argument + NAME + ' ' + 'fg' + EQUAL + '=' + STRING + "'blue'" + /argument + COMMA + ',' + argument + NAME + ' ' + 'nl' + EQUAL + '=' + NAME + 'False' + /argument + /arglist + RPAR + ')' + /trailer + /power + NEWLINE + '\n' + /simple_stmt + if_stmt + NAME + ' ' + 'if' + power + NAME + ' ' + 'node' + trailer + DOT + '.' + NAME + 'prefix' + /trailer + /power + COLON + ':' + suite + NEWLINE + '\n' + INDENT + '' + simple_stmt + power + NAME + " # We don't have to handle prefixes for `Node` objects since\n # that delegates to the first child anyway.\n " + 'out' + trailer + LPAR + '(' + arglist + fstring + FSTRING_START + "f'" + FSTRING_MIDDLE + ' ' + fstring_replacement_field + LBRACE + '{' + power + NAME + 'node' + trailer + DOT + '.' + NAME + 'prefix' + /trailer + /power + BANG + '!' + NAME + 'r' + RBRACE + '}' + /fstring_replacement_field + FSTRING_END + "'" + /fstring + COMMA + ',' + argument + NAME + ' ' + 'fg' + EQUAL + '=' + STRING + "'green'" + /argument + COMMA + ',' + argument + NAME + ' ' + 'bold' + EQUAL + '=' + NAME + 'False' + /argument + COMMA + ',' + argument + NAME + ' ' + 'nl' + EQUAL + '=' + NAME + 'False' + /argument + /arglist + RPAR + ')' + /trailer + /power + NEWLINE + '\n' + /simple_stmt + DEDENT + '' + /suite + /if_stmt + simple_stmt + power + NAME + ' ' + 'out' + trailer + LPAR + '(' + arglist + fstring + FSTRING_START + "f'" + FSTRING_MIDDLE + ' ' + fstring_replacement_field + LBRACE + '{' + power + NAME + 'node' + trailer + DOT + '.' + NAME + 'value' + /trailer + /power + BANG + '!' + NAME + 'r' + RBRACE + '}' + /fstring_replacement_field + FSTRING_END + "'" + /fstring + COMMA + ',' + argument + NAME + ' ' + 'fg' + EQUAL + '=' + STRING + "'blue'" + /argument + COMMA + ',' + argument + NAME + ' ' + 'bold' + EQUAL + '=' + NAME + 'False' + /argument + /arglist + RPAR + ')' + /trailer + /power + NEWLINE + '\n' + /simple_stmt + DEDENT + '' + /suite + /if_stmt + DEDENT + '' + /suite + /funcdef + decorated + decorator + AT + '\n ' + '@' + NAME + 'classmethod' + NEWLINE + '\n' + /decorator + funcdef + NAME + ' ' + 'def' + NAME + ' ' + 'show' + parameters + LPAR + '(' + typedargslist + NAME + 'cls' + COMMA + ',' + tname + NAME + ' ' + 'code' + COLON + ':' + NAME + ' ' + 'str' + /tname + /typedargslist + RPAR + ')' + /parameters + RARROW + ' ' + '->' + NAME + ' ' + 'None' + COLON + ':' + suite + NEWLINE + '\n' + INDENT + '' + simple_stmt + STRING + ' ' + '"""Pretty-prints a given string of `code`.\n\n Convenience method for debugging.\n """' + NEWLINE + '\n' + /simple_stmt + simple_stmt + expr_stmt + NAME + ' ' + 'v' + annassign + COLON + ':' + power + NAME + ' ' + 'DebugVisitor' + trailer + LSQB + '[' + NAME + 'None' + RSQB + ']' + /trailer + /power + EQUAL + ' ' + '=' + power + NAME + ' ' + 'DebugVisitor' + trailer + LPAR + '(' + RPAR + ')' + /trailer + /power + /annassign + /expr_stmt + NEWLINE + '\n' + /simple_stmt + simple_stmt + power + NAME + ' ' + 'list' + trailer + LPAR + '(' + power + NAME + 'v' + trailer + DOT + '.' + NAME + 'visit' + /trailer + trailer + LPAR + '(' + power + NAME + 'lib2to3_parse' + trailer + LPAR + '(' + NAME + 'code' + RPAR + ')' + /trailer + /power + RPAR + ')' + /trailer + /power + RPAR + ')' + /trailer + /power + NEWLINE + '\n' + /simple_stmt + DEDENT + '' + /suite + /funcdef + /decorated + DEDENT + '' + /suite + /classdef + /decorated + ENDMARKER + '' +/file_input diff --git a/tests/data/miscellaneous/debug_visitor.py b/tests/data/miscellaneous/debug_visitor.py new file mode 100644 index 0000000..d1d1ba1 --- /dev/null +++ b/tests/data/miscellaneous/debug_visitor.py @@ -0,0 +1,32 @@ +@dataclass +class DebugVisitor(Visitor[T]): + tree_depth: int = 0 + + def visit_default(self, node: LN) -> Iterator[T]: + indent = ' ' * (2 * self.tree_depth) + if isinstance(node, Node): + _type = type_repr(node.type) + out(f'{indent}{_type}', fg='yellow') + self.tree_depth += 1 + for child in node.children: + yield from self.visit(child) + + self.tree_depth -= 1 + out(f'{indent}/{_type}', fg='yellow', bold=False) + else: + _type = token.tok_name.get(node.type, str(node.type)) + out(f'{indent}{_type}', fg='blue', nl=False) + if node.prefix: + # We don't have to handle prefixes for `Node` objects since + # that delegates to the first child anyway. + out(f' {node.prefix!r}', fg='green', bold=False, nl=False) + out(f' {node.value!r}', fg='blue', bold=False) + + @classmethod + def show(cls, code: str) -> None: + """Pretty-prints a given string of `code`. + + Convenience method for debugging. + """ + v: DebugVisitor[None] = DebugVisitor() + list(v.visit(lib2to3_parse(code))) diff --git a/tests/data/miscellaneous/decorators.py b/tests/data/miscellaneous/decorators.py new file mode 100644 index 0000000..a0f38ca --- /dev/null +++ b/tests/data/miscellaneous/decorators.py @@ -0,0 +1,182 @@ +# This file doesn't use the standard decomposition. +# Decorator syntax test cases are separated by double # comments. +# Those before the 'output' comment are valid under the old syntax. +# Those after the 'ouput' comment require PEP614 relaxed syntax. +# Do not remove the double # separator before the first test case, it allows +# the comment before the test case to be ignored. + +## + +@decorator +def f(): + ... + +## + +@decorator() +def f(): + ... + +## + +@decorator(arg) +def f(): + ... + +## + +@decorator(kwarg=0) +def f(): + ... + +## + +@decorator(*args) +def f(): + ... + +## + +@decorator(**kwargs) +def f(): + ... + +## + +@decorator(*args, **kwargs) +def f(): + ... + +## + +@decorator(*args, **kwargs,) +def f(): + ... + +## + +@dotted.decorator +def f(): + ... + +## + +@dotted.decorator(arg) +def f(): + ... + +## + +@dotted.decorator(kwarg=0) +def f(): + ... + +## + +@dotted.decorator(*args) +def f(): + ... + +## + +@dotted.decorator(**kwargs) +def f(): + ... + +## + +@dotted.decorator(*args, **kwargs) +def f(): + ... + +## + +@dotted.decorator(*args, **kwargs,) +def f(): + ... + +## + +@double.dotted.decorator +def f(): + ... + +## + +@double.dotted.decorator(arg) +def f(): + ... + +## + +@double.dotted.decorator(kwarg=0) +def f(): + ... + +## + +@double.dotted.decorator(*args) +def f(): + ... + +## + +@double.dotted.decorator(**kwargs) +def f(): + ... + +## + +@double.dotted.decorator(*args, **kwargs) +def f(): + ... + +## + +@double.dotted.decorator(*args, **kwargs,) +def f(): + ... + +## + +@_(sequence["decorator"]) +def f(): + ... + +## + +@eval("sequence['decorator']") +def f(): + ... + +# output + +## + +@decorator()() +def f(): + ... + +## + +@(decorator) +def f(): + ... + +## + +@sequence["decorator"] +def f(): + ... + +## + +@decorator[List[str]] +def f(): + ... + +## + +@var := decorator +def f(): + ... \ No newline at end of file diff --git a/tests/data/miscellaneous/expression_skip_magic_trailing_comma.diff b/tests/data/miscellaneous/expression_skip_magic_trailing_comma.diff new file mode 100644 index 0000000..d17467b --- /dev/null +++ b/tests/data/miscellaneous/expression_skip_magic_trailing_comma.diff @@ -0,0 +1,448 @@ +--- [Deterministic header] ++++ [Deterministic header] +@@ -1,8 +1,8 @@ + ... +-'some_string' +-b'\\xa3' ++"some_string" ++b"\\xa3" + Name + None + True + False + 1 +@@ -21,99 +21,118 @@ + Name1 or (Name2 and Name3) or Name4 + Name1 or Name2 and Name3 or Name4 + v1 << 2 + 1 >> v2 + 1 % finished +-1 + v2 - v3 * 4 ^ 5 ** v6 / 7 // 8 +-((1 + v2) - (v3 * 4)) ^ (((5 ** v6) / 7) // 8) ++1 + v2 - v3 * 4 ^ 5**v6 / 7 // 8 ++((1 + v2) - (v3 * 4)) ^ (((5**v6) / 7) // 8) + not great + ~great + +value + -1 + ~int and not v1 ^ 123 + v2 | True + (~int) and (not ((v1 ^ (123 + v2)) | True)) +-+really ** -confusing ** ~operator ** -precedence +-flags & ~ select.EPOLLIN and waiters.write_task is not None +++(really ** -(confusing ** ~(operator**-precedence))) ++flags & ~select.EPOLLIN and waiters.write_task is not None + lambda arg: None + lambda a=True: a + lambda a, b, c=True: a +-lambda a, b, c=True, *, d=(1 << v2), e='str': a +-lambda a, b, c=True, *vararg, d=(v1 << 2), e='str', **kwargs: a + b ++lambda a, b, c=True, *, d=(1 << v2), e="str": a ++lambda a, b, c=True, *vararg, d=(v1 << 2), e="str", **kwargs: a + b + manylambdas = lambda x=lambda y=lambda z=1: z: y(): x() +-foo = (lambda port_id, ignore_missing: {"port1": port1_resource, "port2": port2_resource}[port_id]) ++foo = lambda port_id, ignore_missing: { ++ "port1": port1_resource, ++ "port2": port2_resource, ++}[port_id] + 1 if True else 2 + str or None if True else str or bytes or None + (str or None) if True else (str or bytes or None) + str or None if (1 if True else 2) else str or bytes or None + (str or None) if (1 if True else 2) else (str or bytes or None) +-((super_long_variable_name or None) if (1 if super_long_test_name else 2) else (str or bytes or None)) +-{'2.7': dead, '3.7': (long_live or die_hard)} +-{'2.7': dead, '3.7': (long_live or die_hard), **{'3.6': verygood}} ++( ++ (super_long_variable_name or None) ++ if (1 if super_long_test_name else 2) ++ else (str or bytes or None) ++) ++{"2.7": dead, "3.7": (long_live or die_hard)} ++{"2.7": dead, "3.7": (long_live or die_hard), **{"3.6": verygood}} + {**a, **b, **c} +-{'2.7', '3.6', '3.7', '3.8', '3.9', ('4.0' if gilectomy else '3.10')} +-({'a': 'b'}, (True or False), (+value), 'string', b'bytes') or None ++{"2.7", "3.6", "3.7", "3.8", "3.9", ("4.0" if gilectomy else "3.10")} ++({"a": "b"}, (True or False), (+value), "string", b"bytes") or None + () + (1,) + (1, 2) + (1, 2, 3) + [] + [1, 2, 3, 4, 5, 6, 7, 8, 9, (10 or A), (11 or B), (12 or C)] +-[1, 2, 3,] ++[1, 2, 3] + [*a] + [*range(10)] +-[*a, 4, 5,] +-[4, *a, 5,] +-[this_is_a_very_long_variable_which_will_force_a_delimiter_split, element, another, *more] ++[*a, 4, 5] ++[4, *a, 5] ++[ ++ this_is_a_very_long_variable_which_will_force_a_delimiter_split, ++ element, ++ another, ++ *more, ++] + {i for i in (1, 2, 3)} +-{(i ** 2) for i in (1, 2, 3)} +-{(i ** 2) for i, _ in ((1, 'a'), (2, 'b'), (3, 'c'))} +-{((i ** 2) + j) for i in (1, 2, 3) for j in (1, 2, 3)} ++{(i**2) for i in (1, 2, 3)} ++{(i**2) for i, _ in ((1, "a"), (2, "b"), (3, "c"))} ++{((i**2) + j) for i in (1, 2, 3) for j in (1, 2, 3)} + [i for i in (1, 2, 3)] +-[(i ** 2) for i in (1, 2, 3)] +-[(i ** 2) for i, _ in ((1, 'a'), (2, 'b'), (3, 'c'))] +-[((i ** 2) + j) for i in (1, 2, 3) for j in (1, 2, 3)] ++[(i**2) for i in (1, 2, 3)] ++[(i**2) for i, _ in ((1, "a"), (2, "b"), (3, "c"))] ++[((i**2) + j) for i in (1, 2, 3) for j in (1, 2, 3)] + {i: 0 for i in (1, 2, 3)} +-{i: j for i, j in ((1, 'a'), (2, 'b'), (3, 'c'))} ++{i: j for i, j in ((1, "a"), (2, "b"), (3, "c"))} + {a: b * 2 for a, b in dictionary.items()} + {a: b * -2 for a, b in dictionary.items()} +-{k: v for k, v in this_is_a_very_long_variable_which_will_cause_a_trailing_comma_which_breaks_the_comprehension} ++{ ++ k: v ++ for k, v in this_is_a_very_long_variable_which_will_cause_a_trailing_comma_which_breaks_the_comprehension ++} + Python3 > Python2 > COBOL + Life is Life + call() + call(arg) +-call(kwarg='hey') +-call(arg, kwarg='hey') +-call(arg, another, kwarg='hey', **kwargs) +-call(this_is_a_very_long_variable_which_will_force_a_delimiter_split, arg, another, kwarg='hey', **kwargs) # note: no trailing comma pre-3.6 ++call(kwarg="hey") ++call(arg, kwarg="hey") ++call(arg, another, kwarg="hey", **kwargs) ++call( ++ this_is_a_very_long_variable_which_will_force_a_delimiter_split, ++ arg, ++ another, ++ kwarg="hey", ++ **kwargs ++) # note: no trailing comma pre-3.6 + call(*gidgets[:2]) + call(a, *gidgets[:2]) + call(**self.screen_kwargs) + call(b, **self.screen_kwargs) + lukasz.langa.pl + call.me(maybe) +-1 .real +-1.0 .real ++(1).real ++(1.0).real + ....__class__ + list[str] + dict[str, int] + tuple[str, ...] +-tuple[ +- str, int, float, dict[str, int] +-] +-tuple[str, int, float, dict[str, int],] ++tuple[str, int, float, dict[str, int]] ++tuple[str, int, float, dict[str, int]] + very_long_variable_name_filters: t.List[ + t.Tuple[str, t.Union[str, t.List[t.Optional[str]]]], + ] + xxxx_xxxxx_xxxx_xxx: Callable[..., List[SomeClass]] = classmethod( # type: ignore + sync(async_xxxx_xxx_xxxx_xxxxx_xxxx_xxx.__func__) + ) + xxxx_xxx_xxxx_xxxxx_xxxx_xxx: Callable[..., List[SomeClass]] = classmethod( # type: ignore + sync(async_xxxx_xxx_xxxx_xxxxx_xxxx_xxx.__func__) + ) +-xxxx_xxx_xxxx_xxxxx_xxxx_xxx: Callable[ +- ..., List[SomeClass] +-] = classmethod(sync(async_xxxx_xxx_xxxx_xxxxx_xxxx_xxx.__func__)) # type: ignore ++xxxx_xxx_xxxx_xxxxx_xxxx_xxx: Callable[..., List[SomeClass]] = classmethod( ++ sync(async_xxxx_xxx_xxxx_xxxxx_xxxx_xxx.__func__) ++) # type: ignore + slice[0] + slice[0:1] + slice[0:1:2] + slice[:] + slice[:-1] +@@ -137,118 +156,197 @@ + numpy[-(c + 1) :, d] + numpy[:, l[-2]] + numpy[:, ::-1] + numpy[np.newaxis, :] + (str or None) if (sys.version_info[0] > (3,)) else (str or bytes or None) +-{'2.7': dead, '3.7': long_live or die_hard} +-{'2.7', '3.6', '3.7', '3.8', '3.9', '4.0' if gilectomy else '3.10'} ++{"2.7": dead, "3.7": long_live or die_hard} ++{"2.7", "3.6", "3.7", "3.8", "3.9", "4.0" if gilectomy else "3.10"} + [1, 2, 3, 4, 5, 6, 7, 8, 9, 10 or A, 11 or B, 12 or C] + (SomeName) + SomeName + (Good, Bad, Ugly) + (i for i in (1, 2, 3)) +-((i ** 2) for i in (1, 2, 3)) +-((i ** 2) for i, _ in ((1, 'a'), (2, 'b'), (3, 'c'))) +-(((i ** 2) + j) for i in (1, 2, 3) for j in (1, 2, 3)) ++((i**2) for i in (1, 2, 3)) ++((i**2) for i, _ in ((1, "a"), (2, "b"), (3, "c"))) ++(((i**2) + j) for i in (1, 2, 3) for j in (1, 2, 3)) + (*starred,) +-{"id": "1","type": "type","started_at": now(),"ended_at": now() + timedelta(days=10),"priority": 1,"import_session_id": 1,**kwargs} ++{ ++ "id": "1", ++ "type": "type", ++ "started_at": now(), ++ "ended_at": now() + timedelta(days=10), ++ "priority": 1, ++ "import_session_id": 1, ++ **kwargs, ++} + a = (1,) +-b = 1, ++b = (1,) + c = 1 + d = (1,) + a + (2,) + e = (1,).count(1) + f = 1, *range(10) + g = 1, *"ten" +-what_is_up_with_those_new_coord_names = (coord_names + set(vars_to_create)) + set(vars_to_remove) +-what_is_up_with_those_new_coord_names = (coord_names | set(vars_to_create)) - set(vars_to_remove) +-result = session.query(models.Customer.id).filter(models.Customer.account_id == account_id, models.Customer.email == email_address).order_by(models.Customer.id.asc()).all() +-result = session.query(models.Customer.id).filter(models.Customer.account_id == account_id, models.Customer.email == email_address).order_by(models.Customer.id.asc(),).all() ++what_is_up_with_those_new_coord_names = (coord_names + set(vars_to_create)) + set( ++ vars_to_remove ++) ++what_is_up_with_those_new_coord_names = (coord_names | set(vars_to_create)) - set( ++ vars_to_remove ++) ++result = ( ++ session.query(models.Customer.id) ++ .filter( ++ models.Customer.account_id == account_id, models.Customer.email == email_address ++ ) ++ .order_by(models.Customer.id.asc()) ++ .all() ++) ++result = ( ++ session.query(models.Customer.id) ++ .filter( ++ models.Customer.account_id == account_id, models.Customer.email == email_address ++ ) ++ .order_by(models.Customer.id.asc()) ++ .all() ++) + Ø = set() + authors.łukasz.say_thanks() + mapping = { + A: 0.25 * (10.0 / 12), + B: 0.1 * (10.0 / 12), + C: 0.1 * (10.0 / 12), + D: 0.1 * (10.0 / 12), + } + ++ + def gen(): + yield from outside_of_generator +- a = (yield) +- b = ((yield)) +- c = (((yield))) ++ a = yield ++ b = yield ++ c = yield ++ + + async def f(): + await some.complicated[0].call(with_args=(True or (1 is not 1))) +-print(* [] or [1]) ++ ++ ++print(*[] or [1]) + print(**{1: 3} if False else {x: x for x in range(3)}) +-print(* lambda x: x) +-assert(not Test),("Short message") +-assert this is ComplexTest and not requirements.fit_in_a_single_line(force=False), "Short message" +-assert(((parens is TooMany))) +-for x, in (1,), (2,), (3,): ... +-for y in (): ... +-for z in (i for i in (1, 2, 3)): ... +-for i in (call()): ... +-for j in (1 + (2 + 3)): ... +-while(this and that): ... +-for addr_family, addr_type, addr_proto, addr_canonname, addr_sockaddr in socket.getaddrinfo('google.com', 'http'): ++print(*lambda x: x) ++assert not Test, "Short message" ++assert this is ComplexTest and not requirements.fit_in_a_single_line( ++ force=False ++), "Short message" ++assert parens is TooMany ++for (x,) in (1,), (2,), (3,): ++ ... ++for y in (): ++ ... ++for z in (i for i in (1, 2, 3)): ++ ... ++for i in call(): ++ ... ++for j in 1 + (2 + 3): ++ ... ++while this and that: ++ ... ++for ( ++ addr_family, ++ addr_type, ++ addr_proto, ++ addr_canonname, ++ addr_sockaddr, ++) in socket.getaddrinfo("google.com", "http"): + pass +-a = aaaa.bbbb.cccc.dddd.eeee.ffff.gggg.hhhh.iiii.jjjj.kkkk.llll.mmmm.nnnn.oooo.pppp in qqqq.rrrr.ssss.tttt.uuuu.vvvv.xxxx.yyyy.zzzz +-a = aaaa.bbbb.cccc.dddd.eeee.ffff.gggg.hhhh.iiii.jjjj.kkkk.llll.mmmm.nnnn.oooo.pppp not in qqqq.rrrr.ssss.tttt.uuuu.vvvv.xxxx.yyyy.zzzz +-a = aaaa.bbbb.cccc.dddd.eeee.ffff.gggg.hhhh.iiii.jjjj.kkkk.llll.mmmm.nnnn.oooo.pppp is qqqq.rrrr.ssss.tttt.uuuu.vvvv.xxxx.yyyy.zzzz +-a = aaaa.bbbb.cccc.dddd.eeee.ffff.gggg.hhhh.iiii.jjjj.kkkk.llll.mmmm.nnnn.oooo.pppp is not qqqq.rrrr.ssss.tttt.uuuu.vvvv.xxxx.yyyy.zzzz +-if ( +- threading.current_thread() != threading.main_thread() and +- threading.current_thread() != threading.main_thread() or +- signal.getsignal(signal.SIGINT) != signal.default_int_handler +-): +- return True +-if ( +- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa | +- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +-): +- return True +-if ( +- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa & +- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +-): +- return True +-if ( +- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + +- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +-): +- return True +-if ( +- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa - +- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +-): +- return True +-if ( +- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * +- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +-): +- return True +-if ( +- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa / +- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +-): +- return True +-if ( +- ~ aaaa.a + aaaa.b - aaaa.c * aaaa.d / aaaa.e | aaaa.f & aaaa.g % aaaa.h ^ aaaa.i << aaaa.k >> aaaa.l ** aaaa.m // aaaa.n +-): +- return True +-if ( +- ~ aaaaaaaa.a + aaaaaaaa.b - aaaaaaaa.c @ aaaaaaaa.d / aaaaaaaa.e | aaaaaaaa.f & aaaaaaaa.g % aaaaaaaa.h ^ aaaaaaaa.i << aaaaaaaa.k >> aaaaaaaa.l ** aaaaaaaa.m // aaaaaaaa.n +-): +- return True +-if ( +- ~ aaaaaaaaaaaaaaaa.a + aaaaaaaaaaaaaaaa.b - aaaaaaaaaaaaaaaa.c * aaaaaaaaaaaaaaaa.d @ aaaaaaaaaaaaaaaa.e | aaaaaaaaaaaaaaaa.f & aaaaaaaaaaaaaaaa.g % aaaaaaaaaaaaaaaa.h ^ aaaaaaaaaaaaaaaa.i << aaaaaaaaaaaaaaaa.k >> aaaaaaaaaaaaaaaa.l ** aaaaaaaaaaaaaaaa.m // aaaaaaaaaaaaaaaa.n +-): +- return True +-aaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaa - aaaaaaaaaaaaaaaa * (aaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaa) / (aaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaa) ++a = ( ++ aaaa.bbbb.cccc.dddd.eeee.ffff.gggg.hhhh.iiii.jjjj.kkkk.llll.mmmm.nnnn.oooo.pppp ++ in qqqq.rrrr.ssss.tttt.uuuu.vvvv.xxxx.yyyy.zzzz ++) ++a = ( ++ aaaa.bbbb.cccc.dddd.eeee.ffff.gggg.hhhh.iiii.jjjj.kkkk.llll.mmmm.nnnn.oooo.pppp ++ not in qqqq.rrrr.ssss.tttt.uuuu.vvvv.xxxx.yyyy.zzzz ++) ++a = ( ++ aaaa.bbbb.cccc.dddd.eeee.ffff.gggg.hhhh.iiii.jjjj.kkkk.llll.mmmm.nnnn.oooo.pppp ++ is qqqq.rrrr.ssss.tttt.uuuu.vvvv.xxxx.yyyy.zzzz ++) ++a = ( ++ aaaa.bbbb.cccc.dddd.eeee.ffff.gggg.hhhh.iiii.jjjj.kkkk.llll.mmmm.nnnn.oooo.pppp ++ is not qqqq.rrrr.ssss.tttt.uuuu.vvvv.xxxx.yyyy.zzzz ++) ++if ( ++ threading.current_thread() != threading.main_thread() ++ and threading.current_thread() != threading.main_thread() ++ or signal.getsignal(signal.SIGINT) != signal.default_int_handler ++): ++ return True ++if ( ++ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++ | aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++): ++ return True ++if ( ++ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++ & aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++): ++ return True ++if ( ++ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++ + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++): ++ return True ++if ( ++ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++ - aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++): ++ return True ++if ( ++ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++ * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++): ++ return True ++if ( ++ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++ / aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++): ++ return True ++if ( ++ ~aaaa.a + aaaa.b - aaaa.c * aaaa.d / aaaa.e ++ | aaaa.f & aaaa.g % aaaa.h ^ aaaa.i << aaaa.k >> aaaa.l**aaaa.m // aaaa.n ++): ++ return True ++if ( ++ ~aaaaaaaa.a + aaaaaaaa.b - aaaaaaaa.c @ aaaaaaaa.d / aaaaaaaa.e ++ | aaaaaaaa.f & aaaaaaaa.g % aaaaaaaa.h ++ ^ aaaaaaaa.i << aaaaaaaa.k >> aaaaaaaa.l**aaaaaaaa.m // aaaaaaaa.n ++): ++ return True ++if ( ++ ~aaaaaaaaaaaaaaaa.a ++ + aaaaaaaaaaaaaaaa.b ++ - aaaaaaaaaaaaaaaa.c * aaaaaaaaaaaaaaaa.d @ aaaaaaaaaaaaaaaa.e ++ | aaaaaaaaaaaaaaaa.f & aaaaaaaaaaaaaaaa.g % aaaaaaaaaaaaaaaa.h ++ ^ aaaaaaaaaaaaaaaa.i ++ << aaaaaaaaaaaaaaaa.k ++ >> aaaaaaaaaaaaaaaa.l**aaaaaaaaaaaaaaaa.m // aaaaaaaaaaaaaaaa.n ++): ++ return True ++( ++ aaaaaaaaaaaaaaaa ++ + aaaaaaaaaaaaaaaa ++ - aaaaaaaaaaaaaaaa ++ * (aaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaa) ++ / (aaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaa) ++) + aaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaa +-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++( ++ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++ >> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++ << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++) + bbbb >> bbbb * bbbb +-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ^bbbb.a & aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa^aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++( ++ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++ ^ bbbb.a & aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++ ^ aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ++) + last_call() + # standalone comment at ENDMARKER diff --git a/tests/data/miscellaneous/force_py36.py b/tests/data/miscellaneous/force_py36.py new file mode 100644 index 0000000..4c9b703 --- /dev/null +++ b/tests/data/miscellaneous/force_py36.py @@ -0,0 +1,16 @@ +# The input source must not contain any Py36-specific syntax (e.g. argument type +# annotations, trailing comma after *rest) or this test becomes invalid. +def long_function_name(argument_one, argument_two, argument_three, argument_four, argument_five, argument_six, *rest): pass +# output +# The input source must not contain any Py36-specific syntax (e.g. argument type +# annotations, trailing comma after *rest) or this test becomes invalid. +def long_function_name( + argument_one, + argument_two, + argument_three, + argument_four, + argument_five, + argument_six, + *rest, +): + pass diff --git a/tests/data/miscellaneous/force_pyi.py b/tests/data/miscellaneous/force_pyi.py new file mode 100644 index 0000000..40caf30 --- /dev/null +++ b/tests/data/miscellaneous/force_pyi.py @@ -0,0 +1,66 @@ +# flags: --pyi +from typing import Union + +@bird +def zoo(): ... + +class A: ... +@bar +class B: + def BMethod(self) -> None: ... + @overload + def BMethod(self, arg : List[str]) -> None: ... + +class C: ... +@hmm +class D: ... +class E: ... + +@baz +def foo() -> None: + ... + +class F (A , C): ... +def spam() -> None: ... + +@overload +def spam(arg: str) -> str: ... + +var : int = 1 + +def eggs() -> Union[str, int]: ... + +# output + +from typing import Union + +@bird +def zoo(): ... + +class A: ... + +@bar +class B: + def BMethod(self) -> None: ... + @overload + def BMethod(self, arg: List[str]) -> None: ... + +class C: ... + +@hmm +class D: ... + +class E: ... + +@baz +def foo() -> None: ... + +class F(A, C): ... + +def spam() -> None: ... +@overload +def spam(arg: str) -> str: ... + +var: int = 1 + +def eggs() -> Union[str, int]: ... diff --git a/tests/data/miscellaneous/invalid_header.py b/tests/data/miscellaneous/invalid_header.py new file mode 100644 index 0000000..fb49e2f --- /dev/null +++ b/tests/data/miscellaneous/invalid_header.py @@ -0,0 +1,2 @@ +This is not valid Python syntax +y = "This is valid syntax" diff --git a/tests/data/miscellaneous/missing_final_newline.diff b/tests/data/miscellaneous/missing_final_newline.diff new file mode 100644 index 0000000..6d991c7 --- /dev/null +++ b/tests/data/miscellaneous/missing_final_newline.diff @@ -0,0 +1,8 @@ +--- [Deterministic header] ++++ [Deterministic header] +@@ -1,3 +1,3 @@ + # A comment-only file, with no final EOL character + # This triggers https://bugs.python.org/issue2142 +-# This is the line without the EOL character +\ No newline at end of file ++# This is the line without the EOL character diff --git a/tests/data/miscellaneous/missing_final_newline.py b/tests/data/miscellaneous/missing_final_newline.py new file mode 100644 index 0000000..687e136 --- /dev/null +++ b/tests/data/miscellaneous/missing_final_newline.py @@ -0,0 +1,3 @@ +# A comment-only file, with no final EOL character +# This triggers https://bugs.python.org/issue2142 +# This is the line without the EOL character \ No newline at end of file diff --git a/tests/data/miscellaneous/pattern_matching_invalid.py b/tests/data/miscellaneous/pattern_matching_invalid.py new file mode 100644 index 0000000..22b5b94 --- /dev/null +++ b/tests/data/miscellaneous/pattern_matching_invalid.py @@ -0,0 +1,18 @@ +# First match, no errors +match something: + case bla(): + pass + +# Problem on line 10 +match invalid_case: + case valid_case: + pass + case a := b: + pass + case valid_case: + pass + +# No problems either +match something: + case bla(): + pass diff --git a/tests/data/miscellaneous/python2_detection.py b/tests/data/miscellaneous/python2_detection.py new file mode 100644 index 0000000..8de2bb5 --- /dev/null +++ b/tests/data/miscellaneous/python2_detection.py @@ -0,0 +1,90 @@ +# This uses a similar construction to the decorators.py test data file FYI. + +print "hello, world!" + +### + +exec "print('hello, world!')" + +### + +def set_position((x, y), value): + pass + +### + +try: + pass +except Exception, err: + pass + +### + +raise RuntimeError, "I feel like crashing today :p" + +### + +`wow_these_really_did_exist` + +### + +10L + +### + +10l + +### + +0123 + +# output + +print("hello python three!") + +### + +exec("I'm not sure if you can use exec like this but that's not important here!") + +### + +try: + pass +except make_exception(1, 2): + pass + +### + +try: + pass +except Exception as err: + pass + +### + +raise RuntimeError(make_msg(1, 2)) + +### + +raise RuntimeError("boom!",) + +### + +def set_position(x, y, value): + pass + +### + +10 + +### + +0 + +### + +000 + +### + +0o12 \ No newline at end of file diff --git a/tests/data/miscellaneous/string_quotes.py b/tests/data/miscellaneous/string_quotes.py new file mode 100644 index 0000000..6ec088a --- /dev/null +++ b/tests/data/miscellaneous/string_quotes.py @@ -0,0 +1,114 @@ +'''''' + +'\'' +'"' +"'" +"\"" +"Hello" +"Don't do that" +'Here is a "' +'What\'s the deal here?' +"What's the deal \"here\"?" +"And \"here\"?" +"""Strings with "" in them""" +'''Strings with "" in them''' +'''Here's a "''' +'''Here's a " ''' +'''Just a normal triple +quote''' +f"just a normal {f} string" +f'''This is a triple-quoted {f}-string''' +f'MOAR {" ".join([])}' +f"MOAR {' '.join([])}" +r"raw string ftw" +r'Date d\'expiration:(.*)' +r'Tricky "quote' +r'Not-so-tricky \"quote' +rf'{yay}' +'\n\ +The \"quick\"\n\ +brown fox\n\ +jumps over\n\ +the \'lazy\' dog.\n\ +' +re.compile(r'[\\"]') +"x = ''; y = \"\"" +"x = '''; y = \"\"" +"x = ''''; y = \"\"" +"x = '' ''; y = \"\"" +"x = ''; y = \"\"\"" +"x = '''; y = \"\"\"\"" +"x = ''''; y = \"\"\"\"\"" +"x = '' ''; y = \"\"\"\"\"" +'unnecessary \"\"escaping' +"unnecessary \'\'escaping" +'\\""' +"\\''" +'Lots of \\\\\\\\\'quotes\'' +f'{y * " "} \'{z}\'' +f'{{y * " "}} \'{z}\'' +f'\'{z}\' {y * " "}' +f'{y * x} \'{z}\'' +'\'{z}\' {y * " "}' +'{y * x} \'{z}\'' + +# We must bail out if changing the quotes would introduce backslashes in f-string +# expressions. xref: https://github.com/psf/black/issues/2348 +f"\"{b}\"{' ' * (long-len(b)+1)}: \"{sts}\",\n" +f"\"{a}\"{'hello' * b}\"{c}\"" + +# output + +"""""" + +"'" +'"' +"'" +'"' +"Hello" +"Don't do that" +'Here is a "' +"What's the deal here?" +'What\'s the deal "here"?' +'And "here"?' +"""Strings with "" in them""" +"""Strings with "" in them""" +'''Here's a "''' +"""Here's a " """ +"""Just a normal triple +quote""" +f"just a normal {f} string" +f"""This is a triple-quoted {f}-string""" +f'MOAR {" ".join([])}' +f"MOAR {' '.join([])}" +r"raw string ftw" +r"Date d\'expiration:(.*)" +r'Tricky "quote' +r"Not-so-tricky \"quote" +rf"{yay}" +"\nThe \"quick\"\nbrown fox\njumps over\nthe 'lazy' dog.\n" +re.compile(r'[\\"]') +"x = ''; y = \"\"" +"x = '''; y = \"\"" +"x = ''''; y = \"\"" +"x = '' ''; y = \"\"" +'x = \'\'; y = """' +'x = \'\'\'; y = """"' +'x = \'\'\'\'; y = """""' +'x = \'\' \'\'; y = """""' +'unnecessary ""escaping' +"unnecessary ''escaping" +'\\""' +"\\''" +"Lots of \\\\\\\\'quotes'" +f'{y * " "} \'{z}\'' +f"{{y * \" \"}} '{z}'" +f'\'{z}\' {y * " "}' +f"{y * x} '{z}'" +"'{z}' {y * \" \"}" +"{y * x} '{z}'" + +# We must bail out if changing the quotes would introduce backslashes in f-string +# expressions. xref: https://github.com/psf/black/issues/2348 +f"\"{b}\"{' ' * (long-len(b)+1)}: \"{sts}\",\n" +f"\"{a}\"{'hello' * b}\"{c}\"" diff --git a/tests/data/nested_gitignore_tests/pyproject.toml b/tests/data/nested_gitignore_tests/pyproject.toml new file mode 100644 index 0000000..9ba7ec2 --- /dev/null +++ b/tests/data/nested_gitignore_tests/pyproject.toml @@ -0,0 +1,3 @@ +[build-system] +requires = ["setuptools>=41.0", "setuptools-scm", "wheel"] +build-backend = "setuptools.build_meta" diff --git a/tests/data/nested_gitignore_tests/root/.gitignore b/tests/data/nested_gitignore_tests/root/.gitignore new file mode 100644 index 0000000..2987e7b --- /dev/null +++ b/tests/data/nested_gitignore_tests/root/.gitignore @@ -0,0 +1 @@ +a.py diff --git a/tests/data/nested_gitignore_tests/root/b.py b/tests/data/nested_gitignore_tests/root/b.py new file mode 100644 index 0000000..bdeeca3 --- /dev/null +++ b/tests/data/nested_gitignore_tests/root/b.py @@ -0,0 +1 @@ +# should be included diff --git a/tests/data/nested_gitignore_tests/root/c.py b/tests/data/nested_gitignore_tests/root/c.py new file mode 100644 index 0000000..bdeeca3 --- /dev/null +++ b/tests/data/nested_gitignore_tests/root/c.py @@ -0,0 +1 @@ +# should be included diff --git a/tests/data/nested_gitignore_tests/root/child/.gitignore b/tests/data/nested_gitignore_tests/root/child/.gitignore new file mode 100644 index 0000000..6df81dd --- /dev/null +++ b/tests/data/nested_gitignore_tests/root/child/.gitignore @@ -0,0 +1 @@ +b.py diff --git a/tests/data/nested_gitignore_tests/root/child/c.py b/tests/data/nested_gitignore_tests/root/child/c.py new file mode 100644 index 0000000..bdeeca3 --- /dev/null +++ b/tests/data/nested_gitignore_tests/root/child/c.py @@ -0,0 +1 @@ +# should be included diff --git a/tests/data/nested_gitignore_tests/x.py b/tests/data/nested_gitignore_tests/x.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/data/project_metadata/both_pyproject.toml b/tests/data/project_metadata/both_pyproject.toml new file mode 100644 index 0000000..cf8f148 --- /dev/null +++ b/tests/data/project_metadata/both_pyproject.toml @@ -0,0 +1,8 @@ +[project] +name = "test" +version = "1.0.0" +requires-python = ">=3.7,<3.11" + +[tool.black] +line-length = 79 +target-version = ["py310"] diff --git a/tests/data/project_metadata/neither_pyproject.toml b/tests/data/project_metadata/neither_pyproject.toml new file mode 100644 index 0000000..67623d2 --- /dev/null +++ b/tests/data/project_metadata/neither_pyproject.toml @@ -0,0 +1,6 @@ +[project] +name = "test" +version = "1.0.0" + +[tool.black] +line-length = 79 diff --git a/tests/data/project_metadata/only_black_pyproject.toml b/tests/data/project_metadata/only_black_pyproject.toml new file mode 100644 index 0000000..94058bb --- /dev/null +++ b/tests/data/project_metadata/only_black_pyproject.toml @@ -0,0 +1,7 @@ +[project] +name = "test" +version = "1.0.0" + +[tool.black] +line-length = 79 +target-version = ["py310"] diff --git a/tests/data/project_metadata/only_metadata_pyproject.toml b/tests/data/project_metadata/only_metadata_pyproject.toml new file mode 100644 index 0000000..1c8cdbb --- /dev/null +++ b/tests/data/project_metadata/only_metadata_pyproject.toml @@ -0,0 +1,7 @@ +[project] +name = "test" +version = "1.0.0" +requires-python = ">=3.7,<3.11" + +[tool.black] +line-length = 79 diff --git a/tests/empty.toml b/tests/empty.toml new file mode 100644 index 0000000..3908e45 --- /dev/null +++ b/tests/empty.toml @@ -0,0 +1 @@ +# Empty configuration file; used in tests to avoid interference from Black's own config. diff --git a/tests/optional.py b/tests/optional.py new file mode 100644 index 0000000..f9bceb6 --- /dev/null +++ b/tests/optional.py @@ -0,0 +1,133 @@ +""" +Allows configuring optional test markers in config, see pyproject.toml. + +Run optional tests with `pytest --run-optional=...`. + +Mark tests to run only if an optional test ISN'T selected by prepending the mark with +"no_". + +You can specify a "no_" prefix straight in config, in which case you can mark tests +to run when this tests ISN'T selected by omitting the "no_" prefix. + +Specifying the name of the default behavior in `--run-optional=` is harmless. + +Adapted from https://pypi.org/project/pytest-optional-tests/, (c) 2019 Reece Hart +""" + +import itertools +import logging +import re +from functools import lru_cache +from typing import TYPE_CHECKING, Any + +import pytest +from pytest import StashKey + +log = logging.getLogger(__name__) + + +if TYPE_CHECKING: + from _pytest.config import Config + from _pytest.config.argparsing import Parser + from _pytest.mark.structures import MarkDecorator + from _pytest.nodes import Node + + +ALL_POSSIBLE_OPTIONAL_MARKERS = StashKey[frozenset[str]]() +ENABLED_OPTIONAL_MARKERS = StashKey[frozenset[str]]() + + +def pytest_addoption(parser: "Parser") -> None: + group = parser.getgroup("collect") + group.addoption( + "--run-optional", + action="append", + dest="run_optional", + default=None, + help="Optional test markers to run; comma-separated", + ) + parser.addini("optional-tests", "List of optional tests markers", "linelist") + + +def pytest_configure(config: "Config") -> None: + """Optional tests are markers. + + Use the syntax in https://docs.pytest.org/en/stable/mark.html#registering-marks. + """ + # Extract the configured optional-tests from pytest's ini config in a + # version-agnostic way. Depending on pytest version, the value can be a + # string, a list of strings, or a ConfigValue wrapper (with a `.value` attr). + raw_ot_ini: Any = config.inicfg.get("optional-tests") + ot_ini_lines: list[str] = [] + if raw_ot_ini: + value = getattr(raw_ot_ini, "value", raw_ot_ini) + if isinstance(value, str): + ot_ini_lines = value.strip().split("\n") + elif isinstance(value, list): + # Best-effort coercion to strings; pytest inis are textual. + ot_ini_lines = [str(v) for v in value] + else: + # Fallback: ignore unexpected shapes (non-iterable, etc.). + ot_ini_lines = [] + + ot_markers: set[str] = set() + ot_run: set[str] = set() + marker_re = re.compile(r"^\s*(?Pno_)?(?P\w+)(:\s*(?P.*))?") + # Iterate over configured markers discovered above. + for ot in ot_ini_lines: + m = marker_re.match(ot) + if not m: + raise ValueError(f"{ot!r} doesn't match pytest marker syntax") + + marker = (m.group("no") or "") + m.group("marker") + description = m.group("description") + config.addinivalue_line("markers", f"{marker}: {description}") + config.addinivalue_line( + "markers", f"{no(marker)}: run when `{marker}` not passed" + ) + ot_markers.add(marker) + + # collect requested optional tests + passed_args = config.getoption("run_optional") + if passed_args: + ot_run.update(itertools.chain.from_iterable(a.split(",") for a in passed_args)) + ot_run |= {no(excluded) for excluded in ot_markers - ot_run} + ot_markers |= {no(m) for m in ot_markers} + + log.info("optional tests to run: %s", ot_run) + unknown_tests = ot_run - ot_markers + if unknown_tests: + raise ValueError(f"Unknown optional tests wanted: {unknown_tests!r}") + + store = config._store + store[ALL_POSSIBLE_OPTIONAL_MARKERS] = frozenset(ot_markers) + store[ENABLED_OPTIONAL_MARKERS] = frozenset(ot_run) + + +def pytest_collection_modifyitems(config: "Config", items: "list[Node]") -> None: + store = config._store + all_possible_optional_markers = store[ALL_POSSIBLE_OPTIONAL_MARKERS] + enabled_optional_markers = store[ENABLED_OPTIONAL_MARKERS] + + for item in items: + all_markers_on_test = {m.name for m in item.iter_markers()} + optional_markers_on_test = all_markers_on_test & all_possible_optional_markers + if not optional_markers_on_test or ( + optional_markers_on_test & enabled_optional_markers + ): + continue + log.info("skipping non-requested optional: %s", item) + item.add_marker(skip_mark(frozenset(optional_markers_on_test))) + + +@lru_cache +def skip_mark(tests: frozenset[str]) -> "MarkDecorator": + names = ", ".join(sorted(tests)) + return pytest.mark.skip(reason=f"Marked with disabled optional tests ({names})") + + +@lru_cache +def no(name: str) -> str: + if name.startswith("no_"): + return name[len("no_") :] + return "no_" + name diff --git a/tests/test.toml b/tests/test.toml new file mode 100644 index 0000000..e5fb922 --- /dev/null +++ b/tests/test.toml @@ -0,0 +1,17 @@ +[tool.black] +verbose = 1 +--check = "no" +diff = "y" +color = true +line-length = 79 +target-version = ["py36", "py37", "py38"] +exclude='\.pyi?$' +include='\.py?$' +python-cell-magics = ["custom1", "custom2"] + +[v1.0.0-syntax] +# This shouldn't break Black. +contributors = [ + "Foo Bar ", + { name = "Baz Qux", email = "bazqux@example.com", url = "https://example.com/bazqux" } +] diff --git a/tests/test_black.py b/tests/test_black.py new file mode 100644 index 0000000..aa0c820 --- /dev/null +++ b/tests/test_black.py @@ -0,0 +1,3415 @@ +#!/usr/bin/env python3 + +import asyncio +import inspect +import io +import itertools +import logging +import multiprocessing +import os +import re +import sys +import textwrap +import types +from collections.abc import Callable, Iterator, Sequence +from concurrent.futures import ThreadPoolExecutor +from contextlib import contextmanager, redirect_stderr +from dataclasses import fields, replace +from importlib.metadata import version as imp_version +from io import BytesIO +from pathlib import Path, WindowsPath +from platform import system +from tempfile import NamedTemporaryFile, TemporaryDirectory +from typing import Any, TypeVar +from unittest.mock import MagicMock, patch + +import click +import pytest +from click import unstyle +from click.testing import CliRunner as _CliRunner +from packaging.version import Version +from pathspec import GitIgnoreSpec + +import black +import black.files +from black import Feature, TargetVersion +from black import re_compile_maybe_verbose as compile_pattern +from black.cache import FileData, get_cache_dir, get_cache_file +from black.debug import DebugVisitor +from black.mode import Mode, Preview +from black.output import color_diff, diff +from black.parsing import ASTSafetyError, SourceASTParseError +from black.report import Report +from black.strings import lines_with_leading_tabs_expanded + +# Import other test classes +from tests.util import ( + DATA_DIR, + DEFAULT_MODE, + DETERMINISTIC_HEADER, + PROJECT_ROOT, + PY36_VERSIONS, + THIS_DIR, + BlackBaseTestCase, + assert_format, + change_directory, + dump_to_stderr, + ff, + fs, + get_case_path, + read_data, + read_data_from_file, +) + +THIS_FILE = Path(__file__) +EMPTY_CONFIG = THIS_DIR / "data" / "empty_pyproject.toml" +PY36_ARGS = [f"--target-version={version.name.lower()}" for version in PY36_VERSIONS] +DEFAULT_EXCLUDE = black.re_compile_maybe_verbose(black.const.DEFAULT_EXCLUDES) +DEFAULT_INCLUDE = black.re_compile_maybe_verbose(black.const.DEFAULT_INCLUDES) +T = TypeVar("T") +R = TypeVar("R") + +# Match the time output in a diff, but nothing else +DIFF_TIME = re.compile(r"\t[\d\-:+\. ]+") + + +@contextmanager +def cache_dir(exists: bool = True) -> Iterator[Path]: + with TemporaryDirectory() as workspace: + cache_dir = Path(workspace) + if not exists: + cache_dir = cache_dir / "new" + with patch("black.cache.CACHE_DIR", cache_dir): + yield cache_dir + + +@contextmanager +def event_loop() -> Iterator[None]: + loop = asyncio.new_event_loop() + asyncio.set_event_loop(loop) + try: + yield + + finally: + loop.close() + + +class FakeContext(click.Context): + """A fake click Context for when calling functions that need it.""" + + def __init__(self) -> None: + self.default_map: dict[str, Any] = {} + self.params: dict[str, Any] = {} + self.command: click.Command = black.main + # Dummy root, since most of the tests don't care about it + self.obj: dict[str, Any] = {"root": PROJECT_ROOT} + + +class BlackRunner(_CliRunner): + """Make sure STDOUT and STDERR are kept separate when testing Black via its CLI.""" + + def __init__(self) -> None: + if Version(imp_version("click")) >= Version("8.2.0"): + super().__init__() + else: + super().__init__(mix_stderr=False) # type: ignore + + +def invokeBlack( + args: list[str], exit_code: int = 0, ignore_config: bool = True +) -> None: + runner = BlackRunner() + if ignore_config: + args = ["--verbose", "--config", str(THIS_DIR / "empty.toml"), *args] + result = runner.invoke(black.main, args, catch_exceptions=False) + assert result.stdout_bytes is not None + assert result.stderr_bytes is not None + msg = ( + f"Failed with args: {args}\n" + f"stdout: {result.stdout_bytes.decode()!r}\n" + f"stderr: {result.stderr_bytes.decode()!r}\n" + f"exception: {result.exception}" + ) + assert result.exit_code == exit_code, msg + + +class BlackTestCase(BlackBaseTestCase): + invokeBlack = staticmethod(invokeBlack) + + def test_empty_ff(self) -> None: + expected = "" + tmp_file = Path(black.dump_to_file()) + try: + self.assertFalse(ff(tmp_file, write_back=black.WriteBack.YES)) + actual = tmp_file.read_text(encoding="utf-8") + finally: + os.unlink(tmp_file) + self.assertFormatEqual(expected, actual) + + @patch("black.dump_to_file", dump_to_stderr) + def test_one_empty_line(self) -> None: + for nl in ["\n", "\r\n"]: + source = expected = nl + assert_format(source, expected) + + def test_one_empty_line_ff(self) -> None: + for nl in ["\n", "\r\n"]: + expected = nl + tmp_file = Path(black.dump_to_file(nl)) + if system() == "Windows": + # Writing files in text mode automatically uses the system newline, + # but in this case we don't want this for testing reasons. See: + # https://github.com/psf/black/pull/3348 + with open(tmp_file, "wb") as f: + f.write(nl.encode("utf-8")) + try: + self.assertFalse(ff(tmp_file, write_back=black.WriteBack.YES)) + with open(tmp_file, "rb") as f: + actual = f.read().decode("utf-8") + finally: + os.unlink(tmp_file) + self.assertFormatEqual(expected, actual) + + def test_piping(self) -> None: + _, source, expected = read_data_from_file( + PROJECT_ROOT / "src/black/__init__.py" + ) + result = BlackRunner().invoke( + black.main, + [ + "-", + "--fast", + f"--line-length={black.DEFAULT_LINE_LENGTH}", + f"--config={EMPTY_CONFIG}", + ], + input=BytesIO(source.encode("utf-8")), + ) + self.assertEqual(result.exit_code, 0) + self.assertFormatEqual(expected, result.stdout) + if source != result.stdout: + black.assert_equivalent(source, result.stdout) + black.assert_stable(source, result.stdout, DEFAULT_MODE) + + def test_piping_diff(self) -> None: + diff_header = re.compile( + r"(STDIN|STDOUT)\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d\.\d\d\d\d\d\d" + r"\+\d\d:\d\d" + ) + source, _ = read_data("cases", "expression.py") + expected, _ = read_data("cases", "expression.diff") + args = [ + "-", + "--fast", + f"--line-length={black.DEFAULT_LINE_LENGTH}", + "--diff", + f"--config={EMPTY_CONFIG}", + ] + result = BlackRunner().invoke( + black.main, args, input=BytesIO(source.encode("utf-8")) + ) + self.assertEqual(result.exit_code, 0) + actual = diff_header.sub(DETERMINISTIC_HEADER, result.stdout) + actual = actual.rstrip() + "\n" # the diff output has a trailing space + self.assertEqual(expected, actual) + + def test_piping_diff_with_color(self) -> None: + source, _ = read_data("cases", "expression.py") + args = [ + "-", + "--fast", + f"--line-length={black.DEFAULT_LINE_LENGTH}", + "--diff", + "--color", + f"--config={EMPTY_CONFIG}", + ] + result = BlackRunner().invoke( + black.main, args, input=BytesIO(source.encode("utf-8")) + ) + actual = result.output + # Again, the contents are checked in a different test, so only look for colors. + self.assertIn("\033[1m", actual) + self.assertIn("\033[36m", actual) + self.assertIn("\033[32m", actual) + self.assertIn("\033[31m", actual) + self.assertIn("\033[0m", actual) + + def test_piping_diff_with_color_respects_no_color(self) -> None: + source, _ = read_data("cases", "expression.py") + args = [ + "-", + "--fast", + f"--line-length={black.DEFAULT_LINE_LENGTH}", + "--diff", + "--color", + f"--config={EMPTY_CONFIG}", + ] + with patch.dict(os.environ, {"NO_COLOR": "1"}): + result = BlackRunner().invoke( + black.main, args, input=BytesIO(source.encode("utf-8")) + ) + actual = result.output + self.assertNotIn("\033[", actual) + + def test_pep_572_version_detection(self) -> None: + source, _ = read_data("cases", "pep_572") + root = black.lib2to3_parse(source) + features = black.get_features_used(root) + self.assertIn(black.Feature.ASSIGNMENT_EXPRESSIONS, features) + versions = black.detect_target_versions(root) + self.assertIn(black.TargetVersion.PY38, versions) + + def test_pep_695_version_detection(self) -> None: + for file in ("type_aliases", "type_params"): + source, _ = read_data("cases", file) + root = black.lib2to3_parse(source) + features = black.get_features_used(root) + self.assertIn(black.Feature.TYPE_PARAMS, features) + versions = black.detect_target_versions(root) + self.assertIn(black.TargetVersion.PY312, versions) + + def test_pep_696_version_detection(self) -> None: + source, _ = read_data("cases", "type_param_defaults") + samples = [ + source, + "type X[T=int] = float", + "type X[T:int=int]=int", + "type X[*Ts=int]=int", + "type X[*Ts=*int]=int", + "type X[**P=int]=int", + ] + for sample in samples: + root = black.lib2to3_parse(sample) + features = black.get_features_used(root) + self.assertIn(black.Feature.TYPE_PARAM_DEFAULTS, features) + + def test_python315_version_detection(self) -> None: + source, _ = read_data("cases", "python315") + root = black.lib2to3_parse(source) + features = black.get_features_used(root) + self.assertIn(black.Feature.LAZY_IMPORTS, features) + self.assertIn(black.Feature.UNPACKING_IN_COMPREHENSIONS, features) + self.assertNotIn( + black.Feature.LAZY_IMPORTS, + black.get_features_used(black.lib2to3_parse("lazy = 1\n")), + ) + versions = black.detect_target_versions(root) + self.assertIn(black.TargetVersion.PY315, versions) + + def test_expression_ff(self) -> None: + source, expected = read_data("cases", "expression.py") + tmp_file = Path(black.dump_to_file(source)) + try: + self.assertTrue(ff(tmp_file, write_back=black.WriteBack.YES)) + actual = tmp_file.read_text(encoding="utf-8") + finally: + os.unlink(tmp_file) + self.assertFormatEqual(expected, actual) + with patch("black.dump_to_file", dump_to_stderr): + black.assert_equivalent(source, actual) + black.assert_stable(source, actual, DEFAULT_MODE) + + def test_expression_diff(self) -> None: + source, _ = read_data("cases", "expression.py") + expected, _ = read_data("cases", "expression.diff") + tmp_file = Path(black.dump_to_file(source)) + diff_header = re.compile( + rf"{re.escape(str(tmp_file))}\t\d\d\d\d-\d\d-\d\d " + r"\d\d:\d\d:\d\d\.\d\d\d\d\d\d\+\d\d:\d\d" + ) + try: + result = BlackRunner().invoke( + black.main, ["--diff", str(tmp_file), f"--config={EMPTY_CONFIG}"] + ) + self.assertEqual(result.exit_code, 0) + finally: + os.unlink(tmp_file) + actual = result.stdout + actual = diff_header.sub(DETERMINISTIC_HEADER, actual) + if expected != actual: + dump = black.dump_to_file(actual) + msg = ( + "Expected diff isn't equal to the actual. If you made changes to" + " expression.py and this is an anticipated difference, overwrite" + f" tests/data/cases/expression.diff with {dump}" + ) + self.assertEqual(expected, actual, msg) + + def test_expression_diff_with_color(self) -> None: + source, _ = read_data("cases", "expression.py") + expected, _ = read_data("cases", "expression.diff") + tmp_file = Path(black.dump_to_file(source)) + try: + result = BlackRunner().invoke( + black.main, + ["--diff", "--color", str(tmp_file), f"--config={EMPTY_CONFIG}"], + ) + finally: + os.unlink(tmp_file) + actual = result.output + # We check the contents of the diff in `test_expression_diff`. All + # we need to check here is that color codes exist in the result. + self.assertIn("\033[1m", actual) + self.assertIn("\033[36m", actual) + self.assertIn("\033[32m", actual) + self.assertIn("\033[31m", actual) + self.assertIn("\033[0m", actual) + + def test_detect_pos_only_arguments(self) -> None: + source, _ = read_data("cases", "pep_570") + root = black.lib2to3_parse(source) + features = black.get_features_used(root) + self.assertIn(black.Feature.POS_ONLY_ARGUMENTS, features) + versions = black.detect_target_versions(root) + self.assertIn(black.TargetVersion.PY38, versions) + + def test_detect_debug_f_strings(self) -> None: + root = black.lib2to3_parse("""f"{x=}" """) + features = black.get_features_used(root) + self.assertIn(black.Feature.DEBUG_F_STRINGS, features) + versions = black.detect_target_versions(root) + self.assertIn(black.TargetVersion.PY38, versions) + + root = black.lib2to3_parse( + """f"{x}"\nf'{"="}'\nf'{(x:=5)}'\nf'{f(a="3=")}'\nf'{x:=10}'\n""" + ) + features = black.get_features_used(root) + self.assertNotIn(black.Feature.DEBUG_F_STRINGS, features) + + root = black.lib2to3_parse( + """f"heard a rumour that { f'{1+1=}' } ... seems like it could be true" """ + ) + features = black.get_features_used(root) + self.assertIn(black.Feature.DEBUG_F_STRINGS, features) + + @patch("black.dump_to_file", dump_to_stderr) + def test_string_quotes(self) -> None: + source, expected = read_data("miscellaneous", "string_quotes") + mode = black.Mode(unstable=True) + assert_format(source, expected, mode) + mode = replace(mode, string_normalization=False) + not_normalized = fs(source, mode=mode) + self.assertFormatEqual(source.replace("\\\n", ""), not_normalized) + black.assert_equivalent(source, not_normalized) + black.assert_stable(source, not_normalized, mode=mode) + + def test_skip_source_first_line(self) -> None: + source, _ = read_data("miscellaneous", "invalid_header") + tmp_file = Path(black.dump_to_file(source)) + # Full source should fail (invalid syntax at header) + self.invokeBlack([str(tmp_file), "--diff", "--check"], exit_code=123) + # So, skipping the first line should work + result = BlackRunner().invoke( + black.main, [str(tmp_file), "-x", f"--config={EMPTY_CONFIG}"] + ) + self.assertEqual(result.exit_code, 0) + actual = tmp_file.read_text(encoding="utf-8") + self.assertFormatEqual(source, actual) + + def test_skip_source_first_line_when_mixing_newlines(self) -> None: + code_mixing_newlines = b"Header will be skipped\r\ni = [1,2,3]\nj = [1,2,3]\n" + expected = b"Header will be skipped\r\ni = [1, 2, 3]\nj = [1, 2, 3]\n" + with TemporaryDirectory() as workspace: + test_file = Path(workspace) / "skip_header.py" + test_file.write_bytes(code_mixing_newlines) + mode = replace(DEFAULT_MODE, skip_source_first_line=True) + ff(test_file, mode=mode, write_back=black.WriteBack.YES) + self.assertEqual(test_file.read_bytes(), expected) + + def test_skip_magic_trailing_comma(self) -> None: + source, _ = read_data("cases", "expression") + expected, _ = read_data( + "miscellaneous", "expression_skip_magic_trailing_comma.diff" + ) + tmp_file = Path(black.dump_to_file(source)) + diff_header = re.compile( + rf"{re.escape(str(tmp_file))}\t\d\d\d\d-\d\d-\d\d " + r"\d\d:\d\d:\d\d\.\d\d\d\d\d\d\+\d\d:\d\d" + ) + try: + result = BlackRunner().invoke( + black.main, ["-C", "--diff", str(tmp_file), f"--config={EMPTY_CONFIG}"] + ) + self.assertEqual(result.exit_code, 0) + finally: + os.unlink(tmp_file) + actual = result.stdout + actual = diff_header.sub(DETERMINISTIC_HEADER, actual) + actual = actual.rstrip() + "\n" # the diff output has a trailing space + if expected != actual: + dump = black.dump_to_file(actual) + msg = ( + "Expected diff isn't equal to the actual. If you made changes to" + " expression.py and this is an anticipated difference, overwrite" + " tests/data/miscellaneous/expression_skip_magic_trailing_comma.diff" + f" with {dump}" + ) + self.assertEqual(expected, actual, msg) + + @patch("black.dump_to_file", dump_to_stderr) + def test_python37(self) -> None: + source_path = get_case_path("cases", "python37") + _, source, expected = read_data_from_file(source_path) + actual = fs(source) + self.assertFormatEqual(expected, actual) + black.assert_equivalent(source, actual) + black.assert_stable(source, actual, DEFAULT_MODE) + # ensure black can parse this when the target is 3.7 + self.invokeBlack([str(source_path), "--target-version", "py37"]) + + @patch("black.dump_to_file", dump_to_stderr) + def test_python315(self) -> None: + source_path = get_case_path("cases", "python315") + _, source, expected = read_data_from_file(source_path) + actual = fs(source) + self.assertFormatEqual(expected, actual) + if sys.version_info >= (3, 15): + black.assert_equivalent(source, actual) + black.assert_stable(source, actual, DEFAULT_MODE) + self.invokeBlack([str(source_path), "--target-version", "py315", "--fast"]) + + def test_tab_comment_indentation(self) -> None: + contents_tab = "if 1:\n\tif 2:\n\t\tpass\n\t# comment\n\tpass\n" + contents_spc = "if 1:\n if 2:\n pass\n # comment\n pass\n" + self.assertFormatEqual(contents_spc, fs(contents_spc)) + self.assertFormatEqual(contents_spc, fs(contents_tab)) + + contents_tab = "if 1:\n\tif 2:\n\t\tpass\n\t\t# comment\n\tpass\n" + contents_spc = "if 1:\n if 2:\n pass\n # comment\n pass\n" + self.assertFormatEqual(contents_spc, fs(contents_spc)) + self.assertFormatEqual(contents_spc, fs(contents_tab)) + + def test_false_positive_symlink_output_issue_3384(self) -> None: + # Emulate the behavior when using the CLI (`black ./child --verbose`), which + # involves patching some `pathlib.Path` methods. In particular, `is_dir` is + # patched only on its first call: when checking if "./child" is a directory it + # should return True. The "./child" folder exists relative to the cwd when + # running from CLI, but fails when running the tests because cwd is different + project_root = Path(THIS_DIR / "data" / "nested_gitignore_tests") + working_directory = project_root / "root" + + with change_directory(working_directory): + # Note that the root folder (project_root) isn't the folder + # named "root" (aka working_directory) + report = MagicMock(verbose=True) + black.get_sources( + root=project_root, + src=("./child",), + quiet=False, + verbose=True, + include=DEFAULT_INCLUDE, + exclude=None, + report=report, + extend_exclude=None, + force_exclude=None, + stdin_filename=None, + ) + assert not any( + mock_args[1].startswith("is a symbolic link that points outside") + for _, mock_args, _ in report.path_ignored.mock_calls + ), "A symbolic link was reported." + report.path_ignored.assert_called_once_with( + Path(working_directory, "child", "b.py"), + "matches a .gitignore file content", + ) + + def test_report_verbose(self) -> None: + report = Report(verbose=True) + out_lines = [] + err_lines = [] + + def out(msg: str, **kwargs: Any) -> None: + out_lines.append(msg) + + def err(msg: str, **kwargs: Any) -> None: + err_lines.append(msg) + + with patch("black.output._out", out), patch("black.output._err", err): + report.done(Path("f1"), black.Changed.NO) + self.assertEqual(len(out_lines), 1) + self.assertEqual(len(err_lines), 0) + self.assertEqual(out_lines[-1], "f1 already well formatted, good job.") + self.assertEqual(unstyle(str(report)), "1 file left unchanged.") + self.assertEqual(report.return_code, 0) + report.done(Path("f2"), black.Changed.YES) + self.assertEqual(len(out_lines), 2) + self.assertEqual(len(err_lines), 0) + self.assertEqual(out_lines[-1], "reformatted f2") + self.assertEqual( + unstyle(str(report)), "1 file reformatted, 1 file left unchanged." + ) + report.done(Path("f3"), black.Changed.CACHED) + self.assertEqual(len(out_lines), 3) + self.assertEqual(len(err_lines), 0) + self.assertEqual( + out_lines[-1], "f3 wasn't modified on disk since last run." + ) + self.assertEqual( + unstyle(str(report)), "1 file reformatted, 2 files left unchanged." + ) + self.assertEqual(report.return_code, 0) + report.check = True + self.assertEqual(report.return_code, 1) + report.check = False + report.failed(Path("e1"), "boom") + self.assertEqual(len(out_lines), 3) + self.assertEqual(len(err_lines), 1) + self.assertEqual(err_lines[-1], "error: cannot format e1: boom") + self.assertEqual( + unstyle(str(report)), + "1 file reformatted, 2 files left unchanged, 1 file failed to" + " reformat.", + ) + self.assertEqual(report.return_code, 123) + report.done(Path("f3"), black.Changed.YES) + self.assertEqual(len(out_lines), 4) + self.assertEqual(len(err_lines), 1) + self.assertEqual(out_lines[-1], "reformatted f3") + self.assertEqual( + unstyle(str(report)), + "2 files reformatted, 2 files left unchanged, 1 file failed to" + " reformat.", + ) + self.assertEqual(report.return_code, 123) + report.failed(Path("e2"), "boom") + self.assertEqual(len(out_lines), 4) + self.assertEqual(len(err_lines), 2) + self.assertEqual(err_lines[-1], "error: cannot format e2: boom") + self.assertEqual( + unstyle(str(report)), + "2 files reformatted, 2 files left unchanged, 2 files failed to" + " reformat.", + ) + self.assertEqual(report.return_code, 123) + report.path_ignored(Path("wat"), "no match") + self.assertEqual(len(out_lines), 5) + self.assertEqual(len(err_lines), 2) + self.assertEqual(out_lines[-1], "wat ignored: no match") + self.assertEqual( + unstyle(str(report)), + "2 files reformatted, 2 files left unchanged, 2 files failed to" + " reformat.", + ) + self.assertEqual(report.return_code, 123) + report.done(Path("f4"), black.Changed.NO) + self.assertEqual(len(out_lines), 6) + self.assertEqual(len(err_lines), 2) + self.assertEqual(out_lines[-1], "f4 already well formatted, good job.") + self.assertEqual( + unstyle(str(report)), + "2 files reformatted, 3 files left unchanged, 2 files failed to" + " reformat.", + ) + self.assertEqual(report.return_code, 123) + report.check = True + self.assertEqual( + unstyle(str(report)), + "2 files would be reformatted, 3 files would be left unchanged, 2" + " files would fail to reformat.", + ) + report.check = False + report.diff = True + self.assertEqual( + unstyle(str(report)), + "2 files would be reformatted, 3 files would be left unchanged, 2" + " files would fail to reformat.", + ) + + def test_report_quiet(self) -> None: + report = Report(quiet=True) + out_lines = [] + err_lines = [] + + def out(msg: str, **kwargs: Any) -> None: + out_lines.append(msg) + + def err(msg: str, **kwargs: Any) -> None: + err_lines.append(msg) + + with patch("black.output._out", out), patch("black.output._err", err): + report.done(Path("f1"), black.Changed.NO) + self.assertEqual(len(out_lines), 0) + self.assertEqual(len(err_lines), 0) + self.assertEqual(unstyle(str(report)), "1 file left unchanged.") + self.assertEqual(report.return_code, 0) + report.done(Path("f2"), black.Changed.YES) + self.assertEqual(len(out_lines), 0) + self.assertEqual(len(err_lines), 0) + self.assertEqual( + unstyle(str(report)), "1 file reformatted, 1 file left unchanged." + ) + report.done(Path("f3"), black.Changed.CACHED) + self.assertEqual(len(out_lines), 0) + self.assertEqual(len(err_lines), 0) + self.assertEqual( + unstyle(str(report)), "1 file reformatted, 2 files left unchanged." + ) + self.assertEqual(report.return_code, 0) + report.check = True + self.assertEqual(report.return_code, 1) + report.check = False + report.failed(Path("e1"), "boom") + self.assertEqual(len(out_lines), 0) + self.assertEqual(len(err_lines), 1) + self.assertEqual(err_lines[-1], "error: cannot format e1: boom") + self.assertEqual( + unstyle(str(report)), + "1 file reformatted, 2 files left unchanged, 1 file failed to" + " reformat.", + ) + self.assertEqual(report.return_code, 123) + report.done(Path("f3"), black.Changed.YES) + self.assertEqual(len(out_lines), 0) + self.assertEqual(len(err_lines), 1) + self.assertEqual( + unstyle(str(report)), + "2 files reformatted, 2 files left unchanged, 1 file failed to" + " reformat.", + ) + self.assertEqual(report.return_code, 123) + report.failed(Path("e2"), "boom") + self.assertEqual(len(out_lines), 0) + self.assertEqual(len(err_lines), 2) + self.assertEqual(err_lines[-1], "error: cannot format e2: boom") + self.assertEqual( + unstyle(str(report)), + "2 files reformatted, 2 files left unchanged, 2 files failed to" + " reformat.", + ) + self.assertEqual(report.return_code, 123) + report.path_ignored(Path("wat"), "no match") + self.assertEqual(len(out_lines), 0) + self.assertEqual(len(err_lines), 2) + self.assertEqual( + unstyle(str(report)), + "2 files reformatted, 2 files left unchanged, 2 files failed to" + " reformat.", + ) + self.assertEqual(report.return_code, 123) + report.done(Path("f4"), black.Changed.NO) + self.assertEqual(len(out_lines), 0) + self.assertEqual(len(err_lines), 2) + self.assertEqual( + unstyle(str(report)), + "2 files reformatted, 3 files left unchanged, 2 files failed to" + " reformat.", + ) + self.assertEqual(report.return_code, 123) + report.check = True + self.assertEqual( + unstyle(str(report)), + "2 files would be reformatted, 3 files would be left unchanged, 2" + " files would fail to reformat.", + ) + report.check = False + report.diff = True + self.assertEqual( + unstyle(str(report)), + "2 files would be reformatted, 3 files would be left unchanged, 2" + " files would fail to reformat.", + ) + + def test_report_normal(self) -> None: + report = black.Report() + out_lines = [] + err_lines = [] + + def out(msg: str, **kwargs: Any) -> None: + out_lines.append(msg) + + def err(msg: str, **kwargs: Any) -> None: + err_lines.append(msg) + + with patch("black.output._out", out), patch("black.output._err", err): + report.done(Path("f1"), black.Changed.NO) + self.assertEqual(len(out_lines), 0) + self.assertEqual(len(err_lines), 0) + self.assertEqual(unstyle(str(report)), "1 file left unchanged.") + self.assertEqual(report.return_code, 0) + report.done(Path("f2"), black.Changed.YES) + self.assertEqual(len(out_lines), 1) + self.assertEqual(len(err_lines), 0) + self.assertEqual(out_lines[-1], "reformatted f2") + self.assertEqual( + unstyle(str(report)), "1 file reformatted, 1 file left unchanged." + ) + report.done(Path("f3"), black.Changed.CACHED) + self.assertEqual(len(out_lines), 1) + self.assertEqual(len(err_lines), 0) + self.assertEqual(out_lines[-1], "reformatted f2") + self.assertEqual( + unstyle(str(report)), "1 file reformatted, 2 files left unchanged." + ) + self.assertEqual(report.return_code, 0) + report.check = True + self.assertEqual(report.return_code, 1) + report.check = False + report.failed(Path("e1"), "boom") + self.assertEqual(len(out_lines), 1) + self.assertEqual(len(err_lines), 1) + self.assertEqual(err_lines[-1], "error: cannot format e1: boom") + self.assertEqual( + unstyle(str(report)), + "1 file reformatted, 2 files left unchanged, 1 file failed to" + " reformat.", + ) + self.assertEqual(report.return_code, 123) + report.done(Path("f3"), black.Changed.YES) + self.assertEqual(len(out_lines), 2) + self.assertEqual(len(err_lines), 1) + self.assertEqual(out_lines[-1], "reformatted f3") + self.assertEqual( + unstyle(str(report)), + "2 files reformatted, 2 files left unchanged, 1 file failed to" + " reformat.", + ) + self.assertEqual(report.return_code, 123) + report.failed(Path("e2"), "boom") + self.assertEqual(len(out_lines), 2) + self.assertEqual(len(err_lines), 2) + self.assertEqual(err_lines[-1], "error: cannot format e2: boom") + self.assertEqual( + unstyle(str(report)), + "2 files reformatted, 2 files left unchanged, 2 files failed to" + " reformat.", + ) + self.assertEqual(report.return_code, 123) + report.path_ignored(Path("wat"), "no match") + self.assertEqual(len(out_lines), 2) + self.assertEqual(len(err_lines), 2) + self.assertEqual( + unstyle(str(report)), + "2 files reformatted, 2 files left unchanged, 2 files failed to" + " reformat.", + ) + self.assertEqual(report.return_code, 123) + report.done(Path("f4"), black.Changed.NO) + self.assertEqual(len(out_lines), 2) + self.assertEqual(len(err_lines), 2) + self.assertEqual( + unstyle(str(report)), + "2 files reformatted, 3 files left unchanged, 2 files failed to" + " reformat.", + ) + self.assertEqual(report.return_code, 123) + report.check = True + self.assertEqual( + unstyle(str(report)), + "2 files would be reformatted, 3 files would be left unchanged, 2" + " files would fail to reformat.", + ) + report.check = False + report.diff = True + self.assertEqual( + unstyle(str(report)), + "2 files would be reformatted, 3 files would be left unchanged, 2" + " files would fail to reformat.", + ) + + def test_report_respects_no_color(self) -> None: + report = Report() + report.done(Path("f1"), black.Changed.YES) + with patch.dict(os.environ, {"NO_COLOR": "1"}): + output = str(report) + self.assertEqual(output, unstyle(output)) + + def test_lib2to3_parse(self) -> None: + with self.assertRaises(black.InvalidInput): + black.lib2to3_parse("invalid syntax") + + straddling = "x + y" + black.lib2to3_parse(straddling) + black.lib2to3_parse(straddling, {TargetVersion.PY36}) + + py2_only = "print x" + with self.assertRaises(black.InvalidInput): + black.lib2to3_parse(py2_only, {TargetVersion.PY36}) + + py3_only = "exec(x, end=y)" + black.lib2to3_parse(py3_only) + black.lib2to3_parse(py3_only, {TargetVersion.PY36}) + + def test_get_features_used_decorator(self) -> None: + # Test the feature detection of new decorator syntax + # since this makes some test cases of test_get_features_used() + # fails if it fails, this is tested first so that a useful case + # is identified + simples, relaxed = read_data("miscellaneous", "decorators") + # skip explanation comments at the top of the file + for simple_test in simples.split("##")[1:]: + node = black.lib2to3_parse(simple_test) + decorator = str(node.children[0].children[0]).strip() + self.assertNotIn( + Feature.RELAXED_DECORATORS, + black.get_features_used(node), + msg=( + f"decorator '{decorator}' follows python<=3.8 syntax" + "but is detected as 3.9+" + # f"The full node is\n{node!r}" + ), + ) + # skip the '# output' comment at the top of the output part + for relaxed_test in relaxed.split("##")[1:]: + node = black.lib2to3_parse(relaxed_test) + decorator = str(node.children[0].children[0]).strip() + self.assertIn( + Feature.RELAXED_DECORATORS, + black.get_features_used(node), + msg=( + f"decorator '{decorator}' uses python3.9+ syntax" + "but is detected as python<=3.8" + # f"The full node is\n{node!r}" + ), + ) + + def test_get_features_used(self) -> None: + self.check_features_used("def f(*, arg): ...\n", set()) + self.check_features_used( + "def f(*, arg,): ...\n", {Feature.TRAILING_COMMA_IN_DEF} + ) + self.check_features_used("f(*arg,)\n", {Feature.TRAILING_COMMA_IN_CALL}) + self.check_features_used("def f(*, arg): f'string'\n", {Feature.F_STRINGS}) + self.check_features_used("123_456\n", {Feature.NUMERIC_UNDERSCORES}) + self.check_features_used("123456\n", set()) + + source, expected = read_data("cases", "function") + expected_features = { + Feature.TRAILING_COMMA_IN_CALL, + Feature.TRAILING_COMMA_IN_DEF, + Feature.F_STRINGS, + } + self.check_features_used(source, expected_features) + self.check_features_used(expected, expected_features) + + source, expected = read_data("cases", "expression") + self.check_features_used(source, set()) + self.check_features_used(expected, set()) + + self.check_features_used("lambda a, /, b: ...\n", {Feature.POS_ONLY_ARGUMENTS}) + self.check_features_used("def fn(a, /, b): ...", {Feature.POS_ONLY_ARGUMENTS}) + + self.check_features_used("def fn(): yield a, b", set()) + self.check_features_used("def fn(): return a, b", set()) + self.check_features_used("def fn(): yield *b, c", {Feature.UNPACKING_ON_FLOW}) + self.check_features_used( + "def fn(): return a, *b, c", {Feature.UNPACKING_ON_FLOW} + ) + self.check_features_used("x = a, *b, c", set()) + + self.check_features_used("x: Any = regular", set()) + self.check_features_used("x: Any = (regular, regular)", set()) + self.check_features_used("x: Any = Complex(Type(1))[something]", set()) + self.check_features_used( + "x: Tuple[int, ...] = a, b, c", {Feature.ANN_ASSIGN_EXTENDED_RHS} + ) + + self.check_features_used("try: pass\nexcept Something: pass", set()) + self.check_features_used("try: pass\nexcept (*Something,): pass", set()) + self.check_features_used( + "try: pass\nexcept *Group: pass", {Feature.EXCEPT_STAR} + ) + + self.check_features_used("a[*b]", {Feature.VARIADIC_GENERICS}) + self.check_features_used("a[x, *y(), z] = t", {Feature.VARIADIC_GENERICS}) + self.check_features_used("def fn(*args: *T): pass", {Feature.VARIADIC_GENERICS}) + self.check_features_used( + "def fn(*args: *tuple[*T]): pass", {Feature.VARIADIC_GENERICS} + ) + + self.check_features_used("with a: pass", set()) + self.check_features_used("with a, b: pass", set()) + self.check_features_used("with a as b: pass", set()) + self.check_features_used("with a as b, c as d: pass", set()) + self.check_features_used("with (a): pass", set()) + self.check_features_used("with (a, b): pass", set()) + self.check_features_used("with (a, b) as (c, d): pass", set()) + self.check_features_used( + "with (a as b): pass", {Feature.PARENTHESIZED_CONTEXT_MANAGERS} + ) + self.check_features_used( + "with ((a as b)): pass", {Feature.PARENTHESIZED_CONTEXT_MANAGERS} + ) + self.check_features_used( + "with (a, b as c): pass", {Feature.PARENTHESIZED_CONTEXT_MANAGERS} + ) + self.check_features_used( + "with (a, (b as c)): pass", {Feature.PARENTHESIZED_CONTEXT_MANAGERS} + ) + self.check_features_used( + "with ((a, ((b as c)))): pass", {Feature.PARENTHESIZED_CONTEXT_MANAGERS} + ) + self.check_features_used( + "x = t'foo {f'bar'}'", {Feature.T_STRINGS, Feature.F_STRINGS} + ) + + def check_features_used(self, source: str, expected: set[Feature]) -> None: + node = black.lib2to3_parse(source) + actual = black.get_features_used(node) + msg = f"Expected {expected} but got {actual} for {source!r}" + try: + self.assertEqual(actual, expected, msg=msg) + except AssertionError: + DebugVisitor.show(node) + raise + + def test_get_features_used_for_future_flags(self) -> None: + for src, features in [ + ("from __future__ import annotations", {Feature.FUTURE_ANNOTATIONS}), + ( + "from __future__ import (other, annotations)", + {Feature.FUTURE_ANNOTATIONS}, + ), + ("a = 1 + 2\nfrom something import annotations", set()), + ("from __future__ import x, y", set()), + ]: + with self.subTest(src=src, features=sorted(f.value for f in features)): + node = black.lib2to3_parse(src) + future_imports = black.get_future_imports(node) + self.assertEqual( + black.get_features_used(node, future_imports=future_imports), + features, + ) + + def test_get_future_imports(self) -> None: + node = black.lib2to3_parse("\n") + self.assertEqual(set(), black.get_future_imports(node)) + node = black.lib2to3_parse("from __future__ import black\n") + self.assertEqual({"black"}, black.get_future_imports(node)) + node = black.lib2to3_parse("from __future__ import multiple, imports\n") + self.assertEqual({"multiple", "imports"}, black.get_future_imports(node)) + node = black.lib2to3_parse("from __future__ import (parenthesized, imports)\n") + self.assertEqual({"parenthesized", "imports"}, black.get_future_imports(node)) + node = black.lib2to3_parse( + "from __future__ import multiple\nfrom __future__ import imports\n" + ) + self.assertEqual({"multiple", "imports"}, black.get_future_imports(node)) + node = black.lib2to3_parse("# comment\nfrom __future__ import black\n") + self.assertEqual({"black"}, black.get_future_imports(node)) + node = black.lib2to3_parse('"""docstring"""\nfrom __future__ import black\n') + self.assertEqual({"black"}, black.get_future_imports(node)) + node = black.lib2to3_parse("some(other, code)\nfrom __future__ import black\n") + self.assertEqual(set(), black.get_future_imports(node)) + node = black.lib2to3_parse("from some.module import black\n") + self.assertEqual(set(), black.get_future_imports(node)) + node = black.lib2to3_parse( + "from __future__ import unicode_literals as _unicode_literals" + ) + self.assertEqual({"unicode_literals"}, black.get_future_imports(node)) + node = black.lib2to3_parse( + "from __future__ import unicode_literals as _lol, print" + ) + self.assertEqual({"unicode_literals", "print"}, black.get_future_imports(node)) + + @pytest.mark.incompatible_with_mypyc + def test_debug_visitor(self) -> None: + source, _ = read_data("miscellaneous", "debug_visitor") + expected, _ = read_data("miscellaneous", "debug_visitor.out") + out_lines = [] + err_lines = [] + + def out(msg: str, **kwargs: Any) -> None: + out_lines.append(msg) + + def err(msg: str, **kwargs: Any) -> None: + err_lines.append(msg) + + with patch("black.debug.out", out): + DebugVisitor.show(source) + actual = "\n".join(out_lines) + "\n" + log_name = "" + if expected != actual: + log_name = black.dump_to_file(*out_lines) + self.assertEqual( + expected, + actual, + f"AST print out is different. Actual version dumped to {log_name}", + ) + + def test_format_file_contents(self) -> None: + mode = DEFAULT_MODE + empty = "" + with self.assertRaises(black.NothingChanged): + black.format_file_contents(empty, mode=mode, fast=False) + just_nl = "\n" + with self.assertRaises(black.NothingChanged): + black.format_file_contents(just_nl, mode=mode, fast=False) + same = "j = [1, 2, 3]\n" + with self.assertRaises(black.NothingChanged): + black.format_file_contents(same, mode=mode, fast=False) + different = "j = [1,2,3]" + expected = same + actual = black.format_file_contents(different, mode=mode, fast=False) + self.assertEqual(expected, actual) + invalid = "return if you can" + with self.assertRaises(black.InvalidInput) as e: + black.format_file_contents(invalid, mode=mode, fast=False) + self.assertEqual( + str(e.exception), + "Cannot parse: 1:7\n" + " return if you can\n" + " ^\n" + "ParseError: bad input", + ) + just_crlf = "\r\n" + with self.assertRaises(black.NothingChanged): + black.format_file_contents(just_crlf, mode=mode, fast=False) + just_whitespace_nl = "\n\t\n \n\t \n \t\n\n" + actual = black.format_file_contents(just_whitespace_nl, mode=mode, fast=False) + self.assertEqual("\n", actual) + just_whitespace_crlf = "\r\n\t\r\n \r\n\t \r\n \t\r\n\r\n" + actual = black.format_file_contents(just_whitespace_crlf, mode=mode, fast=False) + self.assertEqual("\r\n", actual) + + def test_endmarker(self) -> None: + n = black.lib2to3_parse("\n") + self.assertEqual(n.type, black.syms.file_input) + self.assertEqual(len(n.children), 1) + self.assertEqual(n.children[0].type, black.token.ENDMARKER) + + @patch("tests.conftest.PRINT_FULL_TREE", True) + @patch("tests.conftest.PRINT_TREE_DIFF", False) + @pytest.mark.incompatible_with_mypyc + def test_assertFormatEqual_print_full_tree(self) -> None: + out_lines = [] + err_lines = [] + + def out(msg: str, **kwargs: Any) -> None: + out_lines.append(msg) + + def err(msg: str, **kwargs: Any) -> None: + err_lines.append(msg) + + with patch("black.output._out", out), patch("black.output._err", err): + with self.assertRaises(AssertionError): + self.assertFormatEqual("j = [1, 2, 3]", "j = [1, 2, 3,]") + + out_str = "".join(out_lines) + self.assertIn("Expected tree:", out_str) + self.assertIn("Actual tree:", out_str) + self.assertEqual("".join(err_lines), "") + + @patch("tests.conftest.PRINT_FULL_TREE", False) + @patch("tests.conftest.PRINT_TREE_DIFF", True) + @pytest.mark.incompatible_with_mypyc + def test_assertFormatEqual_print_tree_diff(self) -> None: + out_lines = [] + err_lines = [] + + def out(msg: str, **kwargs: Any) -> None: + out_lines.append(msg) + + def err(msg: str, **kwargs: Any) -> None: + err_lines.append(msg) + + with patch("black.output._out", out), patch("black.output._err", err): + with self.assertRaises(AssertionError): + self.assertFormatEqual("j = [1, 2, 3]\n", "j = [1, 2, 3,]\n") + + out_str = "".join(out_lines) + self.assertIn("Tree Diff:", out_str) + self.assertIn("+ COMMA", out_str) + self.assertIn("+ ','", out_str) + self.assertEqual("".join(err_lines), "") + + @event_loop() + @patch("concurrent.futures.ProcessPoolExecutor", MagicMock(side_effect=OSError)) + def test_works_in_mono_process_only_environment(self) -> None: + with cache_dir() as workspace: + for f in [ + (workspace / "one.py").resolve(), + (workspace / "two.py").resolve(), + ]: + f.write_text('print("hello")\n', encoding="utf-8") + self.invokeBlack([str(workspace)]) + + @event_loop() + def test_invalid_black_num_workers(self) -> None: + for workers in ["abc", "0", "-1"]: + with ( + cache_dir() as workspace, + patch.dict(os.environ, {"BLACK_NUM_WORKERS": workers}), + ): + for f in [ + (workspace / "one.py").resolve(), + (workspace / "two.py").resolve(), + ]: + f.write_text('print("hello")\n', encoding="utf-8") + + result = BlackRunner().invoke(black.main, [str(workspace)]) + + assert result.exit_code == 2 + assert result.exception is not None + assert "BLACK_NUM_WORKERS" in result.stderr + assert "Traceback" not in result.stderr + + @event_loop() + def test_check_diff_use_together(self) -> None: + with cache_dir(): + # Files which will be reformatted. + src1 = get_case_path("miscellaneous", "string_quotes") + self.invokeBlack([str(src1), "--diff", "--check"], exit_code=1) + # Files which will not be reformatted. + src2 = get_case_path("cases", "composition") + self.invokeBlack([str(src2), "--diff", "--check"]) + # Multi file command. + self.invokeBlack([str(src1), str(src2), "--diff", "--check"], exit_code=1) + + def test_no_src_fails(self) -> None: + with cache_dir(): + self.invokeBlack([], exit_code=1) + + def test_src_and_code_fails(self) -> None: + with cache_dir(): + self.invokeBlack([".", "-c", "0"], exit_code=1) + + def test_broken_symlink(self) -> None: + with cache_dir() as workspace: + symlink = workspace / "broken_link.py" + try: + symlink.symlink_to("nonexistent.py") + except (OSError, NotImplementedError) as e: + self.skipTest(f"Can't create symlinks: {e}") + self.invokeBlack([str(workspace.resolve())]) + + def test_single_file_force_pyi(self) -> None: + pyi_mode = replace(DEFAULT_MODE, is_pyi=True) + contents, expected = read_data("miscellaneous", "force_pyi") + with cache_dir() as workspace: + path = (workspace / "file.py").resolve() + path.write_text(contents, encoding="utf-8") + self.invokeBlack([str(path), "--pyi"]) + actual = path.read_text(encoding="utf-8") + # verify cache with --pyi is separate + pyi_cache = black.Cache.read(pyi_mode) + assert not pyi_cache.is_changed(path) + normal_cache = black.Cache.read(DEFAULT_MODE) + assert normal_cache.is_changed(path) + self.assertFormatEqual(expected, actual) + black.assert_equivalent(contents, actual) + black.assert_stable(contents, actual, pyi_mode) + + @event_loop() + def test_multi_file_force_pyi(self) -> None: + reg_mode = DEFAULT_MODE + pyi_mode = replace(DEFAULT_MODE, is_pyi=True) + contents, expected = read_data("miscellaneous", "force_pyi") + with cache_dir() as workspace: + paths = [ + (workspace / "file1.py").resolve(), + (workspace / "file2.py").resolve(), + ] + for path in paths: + path.write_text(contents, encoding="utf-8") + self.invokeBlack([str(p) for p in paths] + ["--pyi"]) + for path in paths: + actual = path.read_text(encoding="utf-8") + self.assertEqual(actual, expected) + # verify cache with --pyi is separate + pyi_cache = black.Cache.read(pyi_mode) + normal_cache = black.Cache.read(reg_mode) + for path in paths: + assert not pyi_cache.is_changed(path) + assert normal_cache.is_changed(path) + + def test_pipe_force_pyi(self) -> None: + source, expected = read_data("miscellaneous", "force_pyi") + result = BlackRunner().invoke( + black.main, ["-", "-q", "--pyi"], input=BytesIO(source.encode("utf-8")) + ) + self.assertEqual(result.exit_code, 0) + actual = result.output + self.assertFormatEqual(actual, expected) + + def test_single_file_force_py36(self) -> None: + reg_mode = DEFAULT_MODE + py36_mode = replace(DEFAULT_MODE, target_versions=PY36_VERSIONS) + source, expected = read_data("miscellaneous", "force_py36") + with cache_dir() as workspace: + path = (workspace / "file.py").resolve() + path.write_text(source, encoding="utf-8") + self.invokeBlack([str(path), *PY36_ARGS]) + actual = path.read_text(encoding="utf-8") + # verify cache with --target-version is separate + py36_cache = black.Cache.read(py36_mode) + assert not py36_cache.is_changed(path) + normal_cache = black.Cache.read(reg_mode) + assert normal_cache.is_changed(path) + self.assertEqual(actual, expected) + + @event_loop() + def test_multi_file_force_py36(self) -> None: + reg_mode = DEFAULT_MODE + py36_mode = replace(DEFAULT_MODE, target_versions=PY36_VERSIONS) + source, expected = read_data("miscellaneous", "force_py36") + with cache_dir() as workspace: + paths = [ + (workspace / "file1.py").resolve(), + (workspace / "file2.py").resolve(), + ] + for path in paths: + path.write_text(source, encoding="utf-8") + self.invokeBlack([str(p) for p in paths] + PY36_ARGS) + for path in paths: + actual = path.read_text(encoding="utf-8") + self.assertEqual(actual, expected) + # verify cache with --target-version is separate + pyi_cache = black.Cache.read(py36_mode) + normal_cache = black.Cache.read(reg_mode) + for path in paths: + assert not pyi_cache.is_changed(path) + assert normal_cache.is_changed(path) + + def test_pipe_force_py36(self) -> None: + source, expected = read_data("miscellaneous", "force_py36") + result = BlackRunner().invoke( + black.main, + ["-", "-q", "--target-version=py36"], + input=BytesIO(source.encode("utf-8")), + ) + self.assertEqual(result.exit_code, 0) + actual = result.output + self.assertFormatEqual(actual, expected) + + @pytest.mark.incompatible_with_mypyc + def test_reformat_one_with_stdin(self) -> None: + with patch( + "black.format_stdin_to_stdout", + return_value=lambda *args, **kwargs: black.Changed.YES, + ) as fsts: + report = MagicMock() + path = Path("-") + black.reformat_one( + path, + fast=True, + write_back=black.WriteBack.YES, + mode=DEFAULT_MODE, + report=report, + ) + fsts.assert_called_once() + report.done.assert_called_with(path, black.Changed.YES) + + @pytest.mark.incompatible_with_mypyc + def test_reformat_one_with_stdin_filename(self) -> None: + with patch( + "black.format_stdin_to_stdout", + return_value=lambda *args, **kwargs: black.Changed.YES, + ) as fsts: + report = MagicMock() + p = "foo.py" + path = Path(f"__BLACK_STDIN_FILENAME__{p}") + expected = Path(p) + black.reformat_one( + path, + fast=True, + write_back=black.WriteBack.YES, + mode=DEFAULT_MODE, + report=report, + ) + fsts.assert_called_once_with( + fast=True, write_back=black.WriteBack.YES, mode=DEFAULT_MODE, lines=() + ) + # __BLACK_STDIN_FILENAME__ should have been stripped + report.done.assert_called_with(expected, black.Changed.YES) + + @pytest.mark.incompatible_with_mypyc + def test_reformat_one_with_stdin_filename_pyi(self) -> None: + with patch( + "black.format_stdin_to_stdout", + return_value=lambda *args, **kwargs: black.Changed.YES, + ) as fsts: + report = MagicMock() + p = "foo.pyi" + path = Path(f"__BLACK_STDIN_FILENAME__{p}") + expected = Path(p) + black.reformat_one( + path, + fast=True, + write_back=black.WriteBack.YES, + mode=DEFAULT_MODE, + report=report, + ) + fsts.assert_called_once_with( + fast=True, + write_back=black.WriteBack.YES, + mode=replace(DEFAULT_MODE, is_pyi=True), + lines=(), + ) + # __BLACK_STDIN_FILENAME__ should have been stripped + report.done.assert_called_with(expected, black.Changed.YES) + + @pytest.mark.incompatible_with_mypyc + def test_reformat_one_with_stdin_filename_ipynb(self) -> None: + with patch( + "black.format_stdin_to_stdout", + return_value=lambda *args, **kwargs: black.Changed.YES, + ) as fsts: + report = MagicMock() + p = "foo.ipynb" + path = Path(f"__BLACK_STDIN_FILENAME__{p}") + expected = Path(p) + black.reformat_one( + path, + fast=True, + write_back=black.WriteBack.YES, + mode=DEFAULT_MODE, + report=report, + ) + fsts.assert_called_once_with( + fast=True, + write_back=black.WriteBack.YES, + mode=replace(DEFAULT_MODE, is_ipynb=True), + lines=(), + ) + # __BLACK_STDIN_FILENAME__ should have been stripped + report.done.assert_called_with(expected, black.Changed.YES) + + @pytest.mark.incompatible_with_mypyc + def test_reformat_one_with_stdin_and_existing_path(self) -> None: + with patch( + "black.format_stdin_to_stdout", + return_value=lambda *args, **kwargs: black.Changed.YES, + ) as fsts: + report = MagicMock() + # Even with an existing file, since we are forcing stdin, black + # should output to stdout and not modify the file inplace + p = THIS_DIR / "data" / "cases" / "collections.py" + # Make sure is_file actually returns True + self.assertTrue(p.is_file()) + path = Path(f"__BLACK_STDIN_FILENAME__{p}") + expected = Path(p) + black.reformat_one( + path, + fast=True, + write_back=black.WriteBack.YES, + mode=DEFAULT_MODE, + report=report, + ) + fsts.assert_called_once() + # __BLACK_STDIN_FILENAME__ should have been stripped + report.done.assert_called_with(expected, black.Changed.YES) + + def test_reformat_one_with_stdin_empty(self) -> None: + cases = [ + ("", ""), + ("\n", "\n"), + ("\r\n", "\r\n"), + (" \t", ""), + (" \t\n\t ", "\n"), + (" \t\r\n\t ", "\r\n"), + ] + + def _new_wrapper( + output: io.StringIO, io_TextIOWrapper: type[io.TextIOWrapper] + ) -> Callable[[Any, Any], io.StringIO | io.TextIOWrapper]: + def get_output(*args: Any, **kwargs: Any) -> io.StringIO | io.TextIOWrapper: + if args == (sys.stdout.buffer,): + # It's `format_stdin_to_stdout()` calling `io.TextIOWrapper()`, + # return our mock object. + return output + # It's something else (i.e. `decode_bytes()`) calling + # `io.TextIOWrapper()`, pass through to the original implementation. + # See discussion in https://github.com/psf/black/pull/2489 + return io_TextIOWrapper(*args, **kwargs) + + return get_output + + for content, expected in cases: + output = io.StringIO() + io_TextIOWrapper = io.TextIOWrapper + + with patch("io.TextIOWrapper", _new_wrapper(output, io_TextIOWrapper)): + try: + black.format_stdin_to_stdout( + fast=True, + content=content, + write_back=black.WriteBack.YES, + mode=DEFAULT_MODE, + ) + except io.UnsupportedOperation: + pass # StringIO does not support detach + assert ( + output.getvalue() == expected + ), f"incorrect formatting of {repr(content)}" + + def test_cli_unstable(self) -> None: + self.invokeBlack(["--unstable", "-c", "0"], exit_code=0) + self.invokeBlack(["--preview", "-c", "0"], exit_code=0) + # Must also pass --preview + self.invokeBlack( + ["--enable-unstable-feature", "string_processing", "-c", "0"], exit_code=1 + ) + self.invokeBlack( + ["--preview", "--enable-unstable-feature", "string_processing", "-c", "0"], + exit_code=0, + ) + self.invokeBlack( + ["--unstable", "--enable-unstable-feature", "string_processing", "-c", "0"], + exit_code=0, + ) + + def test_invalid_cli_regex(self) -> None: + for option in ["--include", "--exclude", "--extend-exclude", "--force-exclude"]: + self.invokeBlack(["-", option, "**()(!!*)"], exit_code=2) + + def test_required_version_matches_version(self) -> None: + self.invokeBlack( + ["--required-version", black.__version__, "-c", "0"], + exit_code=0, + ignore_config=True, + ) + + def test_required_version_matches_partial_version(self) -> None: + self.invokeBlack( + ["--required-version", black.__version__.split(".")[0], "-c", "0"], + exit_code=0, + ignore_config=True, + ) + + def test_required_version_does_not_match_on_minor_version(self) -> None: + self.invokeBlack( + ["--required-version", black.__version__.split(".")[0] + ".999", "-c", "0"], + exit_code=1, + ignore_config=True, + ) + + def test_required_version_does_not_match_version(self) -> None: + result = BlackRunner().invoke( + black.main, + ["--required-version", "20.99b", "-c", "0"], + ) + self.assertEqual(result.exit_code, 1) + self.assertIn("required version", result.stderr) + + def test_preserves_line_endings(self) -> None: + with TemporaryDirectory() as workspace: + test_file = Path(workspace) / "test.py" + for nl in ["\n", "\r\n"]: + contents = nl.join(["def f( ):", " pass"]) + test_file.write_bytes(contents.encode()) + ff(test_file, write_back=black.WriteBack.YES) + updated_contents: bytes = test_file.read_bytes() + self.assertIn(nl.encode(), updated_contents) + if nl == "\n": + self.assertNotIn(b"\r\n", updated_contents) + + def test_preserves_line_endings_via_stdin(self) -> None: + for nl in ["\n", "\r\n"]: + contents = nl.join(["def f( ):", " pass"]) + runner = BlackRunner() + result = runner.invoke( + black.main, ["-", "--fast"], input=BytesIO(contents.encode("utf-8")) + ) + self.assertEqual(result.exit_code, 0) + output = result.stdout_bytes + self.assertIn(nl.encode("utf-8"), output) + if nl == "\n": + self.assertNotIn(b"\r\n", output) + + def test_normalize_line_endings(self) -> None: + with TemporaryDirectory() as workspace: + test_file = Path(workspace) / "test.py" + for data, expected in ( + (b"c\r\nc\n ", b"c\r\nc\r\n"), + (b"l\nl\r\n ", b"l\nl\n"), + ): + test_file.write_bytes(data) + ff(test_file, write_back=black.WriteBack.YES) + self.assertEqual(test_file.read_bytes(), expected) + + def test_root_logger_not_used_directly(self) -> None: + def fail(*args: Any, **kwargs: Any) -> None: + self.fail("Record created with root logger") + + with patch.multiple( + logging.root, + debug=fail, + info=fail, + warning=fail, + error=fail, + critical=fail, + log=fail, + ): + ff(THIS_DIR / "util.py") + + def test_invalid_config_return_code(self) -> None: + tmp_file = Path(black.dump_to_file()) + try: + tmp_config = Path(black.dump_to_file()) + tmp_config.unlink() + args = ["--config", str(tmp_config), str(tmp_file)] + self.invokeBlack(args, exit_code=2, ignore_config=False) + finally: + tmp_file.unlink() + + def test_parse_pyproject_toml(self) -> None: + test_toml_file = THIS_DIR / "test.toml" + config = black.parse_pyproject_toml(str(test_toml_file)) + self.assertEqual(config["verbose"], 1) + self.assertEqual(config["check"], "no") + self.assertEqual(config["diff"], "y") + self.assertEqual(config["color"], True) + self.assertEqual(config["line_length"], 79) + self.assertEqual(config["target_version"], ["py36", "py37", "py38"]) + self.assertEqual(config["python_cell_magics"], ["custom1", "custom2"]) + self.assertEqual(config["exclude"], r"\.pyi?$") + self.assertEqual(config["include"], r"\.py?$") + + def test_spellcheck_pyproject_toml(self) -> None: + test_toml_file = THIS_DIR / "data" / "incorrect_spelling.toml" + result = BlackRunner().invoke( + black.main, + [ + "--code=print('hello world')", + "--verbose", + f"--config={str(test_toml_file)}", + ], + ) + + assert ( + r"Invalid config keys detected: 'ine_length', 'target_ersion' (in" + rf" {test_toml_file})" in result.stderr + ) + + def test_parse_pyproject_toml_project_metadata(self) -> None: + for test_toml, expected in [ + ("only_black_pyproject.toml", ["py310"]), + ("only_metadata_pyproject.toml", ["py37", "py38", "py39", "py310"]), + ("neither_pyproject.toml", None), + ("both_pyproject.toml", ["py310"]), + ]: + test_toml_file = THIS_DIR / "data" / "project_metadata" / test_toml + config = black.parse_pyproject_toml(str(test_toml_file)) + self.assertEqual(config.get("target_version"), expected) + + def test_infer_target_version(self) -> None: + for version, expected in [ + ("3.6", [TargetVersion.PY36]), + ("3.11.0rc1", [TargetVersion.PY311]), + ( + ">=3.10", + [ + TargetVersion.PY310, + TargetVersion.PY311, + TargetVersion.PY312, + TargetVersion.PY313, + TargetVersion.PY314, + TargetVersion.PY315, + ], + ), + ( + ">=3.10.6", + [ + TargetVersion.PY310, + TargetVersion.PY311, + TargetVersion.PY312, + TargetVersion.PY313, + TargetVersion.PY314, + TargetVersion.PY315, + ], + ), + ("<3.6", [TargetVersion.PY33, TargetVersion.PY34, TargetVersion.PY35]), + (">3.7,<3.10", [TargetVersion.PY38, TargetVersion.PY39]), + ( + ">3.7,!=3.8,!=3.9", + [ + TargetVersion.PY310, + TargetVersion.PY311, + TargetVersion.PY312, + TargetVersion.PY313, + TargetVersion.PY314, + TargetVersion.PY315, + ], + ), + ( + "> 3.9.4, != 3.10.3", + [ + TargetVersion.PY39, + TargetVersion.PY310, + TargetVersion.PY311, + TargetVersion.PY312, + TargetVersion.PY313, + TargetVersion.PY314, + TargetVersion.PY315, + ], + ), + ( + "!=3.3,!=3.4", + [ + TargetVersion.PY35, + TargetVersion.PY36, + TargetVersion.PY37, + TargetVersion.PY38, + TargetVersion.PY39, + TargetVersion.PY310, + TargetVersion.PY311, + TargetVersion.PY312, + TargetVersion.PY313, + TargetVersion.PY314, + TargetVersion.PY315, + ], + ), + ( + "==3.*", + [ + TargetVersion.PY33, + TargetVersion.PY34, + TargetVersion.PY35, + TargetVersion.PY36, + TargetVersion.PY37, + TargetVersion.PY38, + TargetVersion.PY39, + TargetVersion.PY310, + TargetVersion.PY311, + TargetVersion.PY312, + TargetVersion.PY313, + TargetVersion.PY314, + TargetVersion.PY315, + ], + ), + ("==3.8.*", [TargetVersion.PY38]), + (None, None), + ("", None), + ("invalid", None), + ("==invalid", None), + (">3.9,!=invalid", None), + ("3", None), + ("3.2", None), + ("2.7.18", None), + ("==2.7", None), + (">3.10,<3.11", None), + ]: + test_toml = {"project": {"requires-python": version}} + result = black.files.infer_target_version(test_toml) + self.assertEqual(result, expected) + + def test_read_pyproject_toml(self) -> None: + test_toml_file = THIS_DIR / "test.toml" + fake_ctx = FakeContext() + black.read_pyproject_toml(fake_ctx, None, str(test_toml_file)) + config = fake_ctx.default_map + self.assertEqual(config["verbose"], "1") + self.assertEqual(config["check"], "no") + self.assertEqual(config["diff"], "y") + self.assertEqual(config["color"], "True") + self.assertEqual(config["line_length"], "79") + self.assertEqual(config["target_version"], ["py36", "py37", "py38"]) + self.assertEqual(config["exclude"], r"\.pyi?$") + self.assertEqual(config["include"], r"\.py?$") + + def test_read_pyproject_toml_rejects_non_string_regex_configs(self) -> None: + for config_key, option_name in [ + ("include", "include"), + ("force-exclude", "force-exclude"), + ]: + with self.subTest(config_key=config_key): + with TemporaryDirectory() as workspace: + config = Path(workspace) / "pyproject.toml" + config.write_text( + f'[tool.black]\n{config_key} = ["not", "a", "regex"]\n', + encoding="utf-8", + ) + + fake_ctx = FakeContext() + with pytest.raises(click.BadOptionUsage) as exc_info: + black.read_pyproject_toml(fake_ctx, None, str(config)) + + assert exc_info.value.option_name == option_name + assert "must be a string" in exc_info.value.message + + def test_cli_rejects_non_string_pyproject_regex_configs(self) -> None: + for config_key in ["include", "force-exclude"]: + with self.subTest(config_key=config_key): + with TemporaryDirectory() as workspace: + config = Path(workspace) / "pyproject.toml" + config.write_text( + f'[tool.black]\n{config_key} = ["not", "a", "regex"]\n', + encoding="utf-8", + ) + + result = BlackRunner().invoke( + black.main, ["--config", str(config), "--code", "print(1)"] + ) + + assert result.exit_code == 2 + assert f"Config key {config_key} must be a string" in result.stderr + + def test_read_pyproject_toml_from_stdin(self) -> None: + with TemporaryDirectory() as workspace: + root = Path(workspace) + + src_dir = root / "src" + src_dir.mkdir() + + src_pyproject = src_dir / "pyproject.toml" + src_pyproject.touch() + + test_toml_content = (THIS_DIR / "test.toml").read_text(encoding="utf-8") + src_pyproject.write_text(test_toml_content, encoding="utf-8") + + src_python = src_dir / "foo.py" + src_python.touch() + + fake_ctx = FakeContext() + fake_ctx.params["src"] = ("-",) + fake_ctx.params["stdin_filename"] = str(src_python) + + with change_directory(root): + black.read_pyproject_toml(fake_ctx, None, None) + + config = fake_ctx.default_map + self.assertEqual(config["verbose"], "1") + self.assertEqual(config["check"], "no") + self.assertEqual(config["diff"], "y") + self.assertEqual(config["color"], "True") + self.assertEqual(config["line_length"], "79") + self.assertEqual(config["target_version"], ["py36", "py37", "py38"]) + self.assertEqual(config["exclude"], r"\.pyi?$") + self.assertEqual(config["include"], r"\.py?$") + + @pytest.mark.incompatible_with_mypyc + def test_find_project_root(self) -> None: + with TemporaryDirectory() as workspace: + root = Path(workspace) + test_dir = root / "test" + test_dir.mkdir() + + src_dir = root / "src" + src_dir.mkdir() + + root_pyproject = root / "pyproject.toml" + root_pyproject.write_text("[tool.black]", encoding="utf-8") + src_pyproject = src_dir / "pyproject.toml" + src_pyproject.write_text("[tool.black]", encoding="utf-8") + src_python = src_dir / "foo.py" + src_python.touch() + + self.assertEqual( + black.find_project_root((src_dir, test_dir)), + (root.resolve(), "pyproject.toml"), + ) + self.assertEqual( + black.find_project_root((src_dir,)), + (src_dir.resolve(), "pyproject.toml"), + ) + self.assertEqual( + black.find_project_root((src_python,)), + (src_dir.resolve(), "pyproject.toml"), + ) + + with change_directory(test_dir): + self.assertEqual( + black.find_project_root(("-",), stdin_filename="../src/a.py"), + (src_dir.resolve(), "pyproject.toml"), + ) + + src_sub = src_dir / "sub" + src_sub.mkdir() + + src_sub_pyproject = src_sub / "pyproject.toml" + src_sub_pyproject.touch() # empty + + src_sub_python = src_sub / "bar.py" + + # we skip src_sub_pyproject since it is missing the [tool.black] section + self.assertEqual( + black.find_project_root((src_sub_python,)), + (src_dir.resolve(), "pyproject.toml"), + ) + + @patch( + "black.files.find_user_pyproject_toml", + ) + def test_find_pyproject_toml(self, find_user_pyproject_toml: MagicMock) -> None: + find_user_pyproject_toml.side_effect = RuntimeError() + + with redirect_stderr(io.StringIO()) as stderr: + result = black.files.find_pyproject_toml( + path_search_start=(str(Path.cwd().root),) + ) + + assert result is None + err = stderr.getvalue() + assert "Ignoring user configuration" in err + + @patch( + "black.files.find_user_pyproject_toml", + black.files.find_user_pyproject_toml.__wrapped__, + ) + def test_find_user_pyproject_toml_linux(self) -> None: + if system() == "Windows": + return + + # Test if XDG_CONFIG_HOME is checked + with TemporaryDirectory() as workspace: + tmp_user_config = Path(workspace) / "black" + with patch.dict("os.environ", {"XDG_CONFIG_HOME": workspace}): + self.assertEqual( + black.files.find_user_pyproject_toml(), tmp_user_config.resolve() + ) + + # Test fallback for XDG_CONFIG_HOME + with patch.dict("os.environ"): + os.environ.pop("XDG_CONFIG_HOME", None) + fallback_user_config = Path("~/.config").expanduser() / "black" + self.assertEqual( + black.files.find_user_pyproject_toml(), fallback_user_config.resolve() + ) + + def test_find_user_pyproject_toml_windows(self) -> None: + if system() != "Windows": + return + + user_config_path = Path.home() / ".black" + self.assertEqual( + black.files.find_user_pyproject_toml(), user_config_path.resolve() + ) + + def test_bpo_33660_workaround(self) -> None: + if system() == "Windows": + return + + root = Path("/") + path = Path("workspace") / "project" + report = black.Report(verbose=True) + resolves_outside = black.resolves_outside_root_or_cannot_stat( + path, root, report + ) + self.assertIs(resolves_outside, False) + + def test_normalize_path_ignore_windows_junctions_outside_of_root(self) -> None: + if system() != "Windows": + return + + with TemporaryDirectory() as workspace: + root = Path(workspace) + junction_dir = root / "junction" + junction_target_outside_of_root = root / ".." + os.system(f"mklink /J {junction_dir} {junction_target_outside_of_root}") + + report = black.Report(verbose=True) + resolves_outside = black.resolves_outside_root_or_cannot_stat( + junction_dir, root, report + ) + # Manually delete for Python < 3.8 + os.system(f"rmdir {junction_dir}") + + self.assertIs(resolves_outside, True) + + def test_newline_comment_interaction(self) -> None: + source = "class A:\\\r\n# type: ignore\n pass\n" + output = black.format_str(source, mode=DEFAULT_MODE) + black.assert_stable(source, output, mode=DEFAULT_MODE) + + def test_bpo_2142_workaround(self) -> None: + # https://bugs.python.org/issue2142 + + source, _ = read_data("miscellaneous", "missing_final_newline") + # read_data adds a trailing newline + source = source.rstrip() + expected, _ = read_data("miscellaneous", "missing_final_newline.diff") + tmp_file = Path(black.dump_to_file(source, ensure_final_newline=False)) + diff_header = re.compile( + rf"{re.escape(str(tmp_file))}\t\d\d\d\d-\d\d-\d\d " + r"\d\d:\d\d:\d\d\.\d\d\d\d\d\d\+\d\d:\d\d" + ) + try: + result = BlackRunner().invoke(black.main, ["--diff", str(tmp_file)]) + self.assertEqual(result.exit_code, 0) + finally: + os.unlink(tmp_file) + actual = result.stdout + actual = diff_header.sub(DETERMINISTIC_HEADER, actual) + self.assertEqual(actual, expected) + + @staticmethod + def compare_results( + result: click.testing.Result, expected_value: str, expected_exit_code: int + ) -> None: + """Helper method to test the value and exit code of a click Result.""" + assert ( + result.stdout == expected_value + ), "The output did not match the expected value." + assert result.exit_code == expected_exit_code, "The exit code is incorrect." + + def test_code_option(self) -> None: + """Test the code option with no changes.""" + code = 'print("Hello world")\n' + args = ["--code", code] + result = BlackRunner().invoke(black.main, args) + + self.compare_results(result, code, 0) + + def test_code_option_changed(self) -> None: + """Test the code option when changes are required.""" + code = "print('hello world')" + formatted = black.format_str(code, mode=DEFAULT_MODE) + + args = ["--code", code] + result = BlackRunner().invoke(black.main, args) + + self.compare_results(result, formatted, 0) + + def test_code_option_check(self) -> None: + """Test the code option when check is passed.""" + args = ["--check", "--code", 'print("Hello world")\n'] + result = BlackRunner().invoke(black.main, args) + self.compare_results(result, "", 0) + + def test_code_option_check_changed(self) -> None: + """Test the code option when changes are required, and check is passed.""" + args = ["--check", "--code", "print('hello world')"] + result = BlackRunner().invoke(black.main, args) + self.compare_results(result, "", 1) + + def test_code_option_diff(self) -> None: + """Test the code option when diff is passed.""" + code = "print('hello world')" + formatted = black.format_str(code, mode=DEFAULT_MODE) + result_diff = diff(code, formatted, "STDIN", "STDOUT") + + args = ["--diff", "--code", code] + result = BlackRunner().invoke(black.main, args) + + # Remove time from diff + output = DIFF_TIME.sub("", result.output) + + assert output == result_diff, "The output did not match the expected value." + assert result.exit_code == 0, "The exit code is incorrect." + + def test_code_option_color_diff(self) -> None: + """Test the code option when color and diff are passed.""" + code = "print('hello world')" + formatted = black.format_str(code, mode=DEFAULT_MODE) + + result_diff = diff(code, formatted, "STDIN", "STDOUT") + result_diff = color_diff(result_diff) + + args = ["--diff", "--color", "--code", code] + result = BlackRunner().invoke(black.main, args) + + # Remove time from diff + output = DIFF_TIME.sub("", result.output) + + assert output == result_diff, "The output did not match the expected value." + assert result.exit_code == 0, "The exit code is incorrect." + + @pytest.mark.incompatible_with_mypyc + def test_code_option_safe(self) -> None: + """Test that the code option throws an error when the sanity checks fail.""" + # Patch black.assert_equivalent to ensure the sanity checks fail + with patch.object(black, "assert_equivalent", side_effect=AssertionError): + code = 'print("Hello world")' + error_msg = f"{code}\nerror: cannot format : \n" + + args = ["--safe", "--code", code] + result = BlackRunner().invoke(black.main, args) + + assert error_msg == result.output + assert result.exit_code == 123 + + def test_code_option_fast(self) -> None: + """Test that the code option ignores errors when the sanity checks fail.""" + # Patch black.assert_equivalent to ensure the sanity checks fail + with patch.object(black, "assert_equivalent", side_effect=AssertionError): + code = 'print("Hello world")' + formatted = black.format_str(code, mode=DEFAULT_MODE) + + args = ["--fast", "--code", code] + result = BlackRunner().invoke(black.main, args) + + self.compare_results(result, formatted, 0) + + @pytest.mark.incompatible_with_mypyc + def test_code_option_config(self) -> None: + """ + Test that the code option finds the pyproject.toml in the current directory. + """ + with patch.object(black, "parse_pyproject_toml", return_value={}) as parse: + args = ["--code", "print"] + # This is the only directory known to contain a pyproject.toml + with change_directory(PROJECT_ROOT): + BlackRunner().invoke(black.main, args) + pyproject_path = Path(Path.cwd(), "pyproject.toml").resolve() + + assert ( + len(parse.mock_calls) >= 1 + ), "Expected config parse to be called with the current directory." + + _, call_args, _ = parse.mock_calls[0] + assert ( + call_args[0].lower() == str(pyproject_path).lower() + ), "Incorrect config loaded." + + @pytest.mark.incompatible_with_mypyc + def test_code_option_parent_config(self) -> None: + """ + Test that the code option finds the pyproject.toml in the parent directory. + """ + with patch.object(black, "parse_pyproject_toml", return_value={}) as parse: + with change_directory(THIS_DIR): + args = ["--code", "print"] + BlackRunner().invoke(black.main, args) + + pyproject_path = Path(Path().cwd().parent, "pyproject.toml").resolve() + assert ( + len(parse.mock_calls) >= 1 + ), "Expected config parse to be called with the current directory." + + _, call_args, _ = parse.mock_calls[0] + assert ( + call_args[0].lower() == str(pyproject_path).lower() + ), "Incorrect config loaded." + + def test_for_handled_unexpected_eof_error(self) -> None: + """ + Test that an unexpected EOF SyntaxError is nicely presented. + """ + with pytest.raises(black.parsing.InvalidInput) as exc_info: + black.lib2to3_parse("print(", {}) + + exc_info.match( + re.escape( + "Cannot parse: 1:6\n" + " print(\n" + " ^\n" + "TokenError: Unexpected EOF in multi-line statement" + ) + ) + + def test_line_ranges_with_code_option(self) -> None: + code = textwrap.dedent("""\ + if a == b: + print ( "OK" ) + """) + args = ["--line-ranges=1-1", "--code", code] + result = BlackRunner().invoke(black.main, args) + + expected = textwrap.dedent("""\ + if a == b: + print ( "OK" ) + """) + self.compare_results(result, expected, expected_exit_code=0) + + def test_line_ranges_with_stdin(self) -> None: + code = textwrap.dedent("""\ + if a == b: + print ( "OK" ) + """) + runner = BlackRunner() + result = runner.invoke( + black.main, ["--line-ranges=1-1", "-"], input=BytesIO(code.encode("utf-8")) + ) + + expected = textwrap.dedent("""\ + if a == b: + print ( "OK" ) + """) + self.compare_results(result, expected, expected_exit_code=0) + + def test_line_ranges_with_source(self) -> None: + with TemporaryDirectory() as workspace: + test_file = Path(workspace) / "test.py" + test_file.write_text( + textwrap.dedent("""\ + if a == b: + print ( "OK" ) + """), + encoding="utf-8", + ) + args = ["--line-ranges=1-1", str(test_file)] + result = BlackRunner().invoke(black.main, args) + assert not result.exit_code + + formatted = test_file.read_text(encoding="utf-8") + expected = textwrap.dedent("""\ + if a == b: + print ( "OK" ) + """) + assert expected == formatted + + def test_line_ranges_with_multiple_sources(self) -> None: + with TemporaryDirectory() as workspace: + test1_file = Path(workspace) / "test1.py" + test1_file.write_text("", encoding="utf-8") + test2_file = Path(workspace) / "test2.py" + test2_file.write_text("", encoding="utf-8") + args = ["--line-ranges=1-1", str(test1_file), str(test2_file)] + result = BlackRunner().invoke(black.main, args) + assert result.exit_code == 1 + assert result.stderr_bytes is not None + assert ( + "Cannot use --line-ranges to format multiple files" + in result.stderr_bytes.decode() + ) + + def test_line_ranges_with_ipynb(self) -> None: + with TemporaryDirectory() as workspace: + test_file = Path(workspace) / "test.ipynb" + test_file.write_text("{}", encoding="utf-8") + args = ["--line-ranges=1-1", "--ipynb", str(test_file)] + result = BlackRunner().invoke(black.main, args) + assert result.stderr_bytes is not None + assert ( + "Cannot use --line-ranges with ipynb files" + in result.stderr_bytes.decode() + ) + assert result.exit_code == 1 + + def test_line_ranges_in_pyproject_toml(self) -> None: + config = THIS_DIR / "data" / "invalid_line_ranges.toml" + result = BlackRunner().invoke( + black.main, ["--code", "print()", "--config", str(config)] + ) + assert result.exit_code == 2 + assert result.stderr_bytes is not None + assert ( + b"Cannot use line-ranges in the pyproject.toml file." in result.stderr_bytes + ) + + def test_lines_with_leading_tabs_expanded(self) -> None: + # See CVE-2024-21503. Mostly test that this completes in a reasonable + # time. + payload = "\t" * 10_000 + assert lines_with_leading_tabs_expanded(payload) == [payload] + + tab = " " * 4 + assert lines_with_leading_tabs_expanded("\tx") == [f"{tab}x"] + assert lines_with_leading_tabs_expanded("\t\tx") == [f"{tab}{tab}x"] + assert lines_with_leading_tabs_expanded("\tx\n y") == [f"{tab}x", " y"] + + def test_carriage_return_edge_cases(self) -> None: + # These tests are here instead of in the normal cases because + # of git's newline normalization and because it's hard to + # get `\r` vs `\r\n` vs `\n` to display properly + assert ( + black.format_str( + "try:\\\r# type: ignore\n pass\nfinally:\n pass\n", + mode=black.FileMode(), + ) + == "try: # type: ignore\r pass\rfinally:\r pass\r" + ) + assert black.format_str("{\r}", mode=black.FileMode()) == "{}\r" + assert black.format_str("pass #\r#\n", mode=black.FileMode()) == "pass #\r#\r" + + assert black.format_str("x=\\\r\n1", mode=black.FileMode()) == "x = 1\r\n" + assert black.format_str("x=\\\n1", mode=black.FileMode()) == "x = 1\n" + assert black.format_str("x=\\\r1", mode=black.FileMode()) == "x = 1\r" + assert ( + black.format_str("class A\\\r\n:...", mode=black.FileMode()) + == "class A: ...\r\n" + ) + assert ( + black.format_str("class A\\\n:...", mode=black.FileMode()) + == "class A: ...\n" + ) + assert ( + black.format_str("class A\\\r:...", mode=black.FileMode()) + == "class A: ...\r" + ) + + def test_newline_type_detection(self) -> None: + mode = Mode() + newline_types = ["A\n", "A\r\n", "A\r"] + for test_case in itertools.permutations(newline_types): + assert black.format_str("".join(test_case), mode=mode) == test_case[0] * 3 + + def test_decode_with_encoding(self) -> None: + # This uses temporary files since some editors (including GitHub) + # struggle with displaying and/or editing non utf-8 data + # \xfc is iso-8859-1 for ü + with NamedTemporaryFile(delete=False) as first_line: + first_line.write( + b"# -*- coding: iso-8859-1 -*-\n" + b"# 2002-11-22 J\xfcrgen Hermann \n" + ) + first_line.close() + self.assertFalse( + ff(Path(first_line.name)), + "Failed to properly detect encoding", + ) + + with NamedTemporaryFile(delete=False) as second_line: + second_line.write( + b"#! /usr/bin/env python3\n" + b"# -*- coding: iso-8859-1 -*-\n" + b"# 2002-11-22 J\xfcrgen Hermann \n" + ) + second_line.close() + self.assertFalse( + ff(Path(second_line.name)), + "Failed to properly detect encoding on second line", + ) + + +class TestCaching: + def test_get_cache_dir( + self, + tmp_path: Path, + monkeypatch: pytest.MonkeyPatch, + ) -> None: + # Create multiple cache directories + workspace1 = tmp_path / "ws1" + workspace1.mkdir() + workspace2 = tmp_path / "ws2" + workspace2.mkdir() + + # Force user_cache_dir to use the temporary directory for easier assertions + patch_user_cache_dir = patch( + target="black.cache.user_cache_dir", + autospec=True, + return_value=str(workspace1), + ) + + # If BLACK_CACHE_DIR is not set, use user_cache_dir + monkeypatch.delenv("BLACK_CACHE_DIR", raising=False) + with patch_user_cache_dir: + assert get_cache_dir().parent == workspace1 + + # If it is set, use the path provided in the env var. + monkeypatch.setenv("BLACK_CACHE_DIR", str(workspace2)) + assert get_cache_dir().parent == workspace2 + + def test_cache_file_length(self) -> None: + cases = [ + DEFAULT_MODE, + # all of the target versions + Mode(target_versions=set(TargetVersion)), + # all of the features + Mode(enabled_features=set(Preview)), + # all of the magics + Mode(python_cell_magics={f"magic{i}" for i in range(500)}), + # all of the things + Mode( + target_versions=set(TargetVersion), + enabled_features=set(Preview), + python_cell_magics={f"magic{i}" for i in range(500)}, + ), + ] + for case in cases: + cache_file = get_cache_file(case) + # Some common file systems enforce a maximum path length + # of 143 (issue #4174). We can't do anything if the directory + # path is too long, but ensure the name of the cache file itself + # doesn't get too crazy. + assert len(cache_file.name) <= 96 + + def test_cache_file_path_ignores_python_cell_magic_separators(self) -> None: + mode = replace(DEFAULT_MODE, python_cell_magics={"../../../tmp/pwned"}) + with cache_dir() as workspace: + cache_file = get_cache_file(mode) + assert cache_file.parent == workspace + assert "/" not in cache_file.name + assert ".." not in cache_file.name + assert "../../../tmp/pwned" not in mode.get_cache_key() + + def test_cache_broken_file(self) -> None: + mode = DEFAULT_MODE + with cache_dir() as workspace: + cache_file = get_cache_file(mode) + cache_file.write_text("this is not a pickle", encoding="utf-8") + assert black.Cache.read(mode).file_data == {} + src = (workspace / "test.py").resolve() + src.write_text("print('hello')", encoding="utf-8") + invokeBlack([str(src)]) + cache = black.Cache.read(mode) + assert not cache.is_changed(src) + + def test_cache_empty_file(self) -> None: + mode = DEFAULT_MODE + with cache_dir(): + cache_file = get_cache_file(mode) + cache_file.touch() + assert black.Cache.read(mode).file_data == {} + + def test_cache_single_file_already_cached(self) -> None: + mode = DEFAULT_MODE + with cache_dir() as workspace: + src = (workspace / "test.py").resolve() + src.write_text("print('hello')", encoding="utf-8") + cache = black.Cache.read(mode) + cache.write([src]) + invokeBlack([str(src)]) + assert src.read_text(encoding="utf-8") == "print('hello')" + + @event_loop() + def test_cache_multiple_files(self) -> None: + mode = DEFAULT_MODE + with ( + cache_dir() as workspace, + patch("concurrent.futures.ProcessPoolExecutor", new=ThreadPoolExecutor), + ): + one = (workspace / "one.py").resolve() + one.write_text("print('hello')", encoding="utf-8") + two = (workspace / "two.py").resolve() + two.write_text("print('hello')", encoding="utf-8") + cache = black.Cache.read(mode) + cache.write([one]) + invokeBlack([str(workspace)]) + assert one.read_text(encoding="utf-8") == "print('hello')" + assert two.read_text(encoding="utf-8") == 'print("hello")\n' + cache = black.Cache.read(mode) + assert not cache.is_changed(one) + assert not cache.is_changed(two) + + @pytest.mark.incompatible_with_mypyc + @pytest.mark.parametrize("color", [False, True], ids=["no-color", "with-color"]) + def test_no_cache_when_writeback_diff(self, color: bool) -> None: + mode = DEFAULT_MODE + with cache_dir() as workspace: + src = (workspace / "test.py").resolve() + src.write_text("print('hello')", encoding="utf-8") + with ( + patch.object(black.Cache, "read") as read_cache, + patch.object(black.Cache, "write") as write_cache, + ): + cmd = [str(src), "--diff"] + if color: + cmd.append("--color") + invokeBlack(cmd) + cache_file = get_cache_file(mode) + assert cache_file.exists() is False + read_cache.assert_called_once() + write_cache.assert_not_called() + + @pytest.mark.parametrize("color", [False, True], ids=["no-color", "with-color"]) + @event_loop() + def test_output_locking_when_writeback_diff(self, color: bool) -> None: + with cache_dir() as workspace: + for tag in range(0, 4): + src = (workspace / f"test{tag}.py").resolve() + src.write_text("print('hello')", encoding="utf-8") + with patch( + "black.concurrency.Manager", wraps=multiprocessing.Manager + ) as mgr: + cmd = ["--diff", str(workspace)] + if color: + cmd.append("--color") + invokeBlack(cmd, exit_code=0) + # this isn't quite doing what we want, but if it _isn't_ + # called then we cannot be using the lock it provides + mgr.assert_called() + + def test_no_cache_when_stdin(self) -> None: + mode = DEFAULT_MODE + with cache_dir(): + result = BlackRunner().invoke( + black.main, ["-"], input=BytesIO(b"print('hello')") + ) + assert not result.exit_code + cache_file = get_cache_file(mode) + assert not cache_file.exists() + + def test_no_cache_flag_prevents_writes(self) -> None: + """--no-cache should neither read nor write the cache""" + mode = DEFAULT_MODE + with cache_dir() as workspace: + src = (workspace / "test.py").resolve() + src.write_text("print('hello')", encoding="utf-8") + cache = black.Cache.read(mode) + # Pre-populate cache so the file is considered cached + cache.write([src]) + with ( + patch.object(black.Cache, "read") as read_cache, + patch.object(black.Cache, "write") as write_cache, + ): + # Pass --no-cache; it should neither read nor write + invokeBlack([str(src), "--no-cache"]) + read_cache.assert_not_called() + write_cache.assert_not_called() + + def test_no_cache_with_multiple_files(self) -> None: + """Formatting multiple files with --no-cache should not read or write cache + and should format files normally.""" + mode = DEFAULT_MODE + with (cache_dir() as workspace,): + one = (workspace / "one.py").resolve() + one.write_text("print('hello')", encoding="utf-8") + two = (workspace / "two.py").resolve() + two.write_text("print('hello')", encoding="utf-8") + + # Pre-populate cache for `one` so it would normally be skipped + cache = black.Cache.read(mode) + cache.write([one]) + + with ( + patch.object(black.Cache, "read") as read_cache, + patch.object(black.Cache, "write") as write_cache, + ): + # Run Black over the directory with --no-cache + invokeBlack([str(workspace), "--no-cache"]) + + # Cache should not be consulted or updated + read_cache.assert_not_called() + write_cache.assert_not_called() + + # Both files should have been formatted (double quotes + newline) + assert one.read_text(encoding="utf-8") == 'print("hello")\n' + assert two.read_text(encoding="utf-8") == 'print("hello")\n' + + def test_read_cache_no_cachefile(self) -> None: + mode = DEFAULT_MODE + with cache_dir(): + assert black.Cache.read(mode).file_data == {} + + def test_write_cache_read_cache(self) -> None: + mode = DEFAULT_MODE + with cache_dir() as workspace: + src = (workspace / "test.py").resolve() + src.touch() + write_cache = black.Cache.read(mode) + write_cache.write([src]) + read_cache = black.Cache.read(mode) + assert not read_cache.is_changed(src) + + @pytest.mark.incompatible_with_mypyc + def test_filter_cached(self) -> None: + with TemporaryDirectory() as workspace: + path = Path(workspace) + uncached = (path / "uncached").resolve() + cached = (path / "cached").resolve() + cached_but_changed = (path / "changed").resolve() + uncached.touch() + cached.touch() + cached_but_changed.touch() + cache = black.Cache.read(DEFAULT_MODE) + + orig_func = black.Cache.get_file_data + + def wrapped_func(path: Path) -> FileData: + if path == cached: + return orig_func(path) + if path == cached_but_changed: + return FileData(0.0, 0, "") + raise AssertionError + + with patch.object(black.Cache, "get_file_data", side_effect=wrapped_func): + cache.write([cached, cached_but_changed]) + todo, done = cache.filtered_cached({uncached, cached, cached_but_changed}) + assert todo == {uncached, cached_but_changed} + assert done == {cached} + + def test_filter_cached_hash(self) -> None: + with TemporaryDirectory() as workspace: + path = Path(workspace) + src = (path / "test.py").resolve() + src.write_text("print('hello')", encoding="utf-8") + st = src.stat() + cache = black.Cache.read(DEFAULT_MODE) + cache.write([src]) + cached_file_data = cache.file_data[str(src)] + + todo, done = cache.filtered_cached([src]) + assert todo == set() + assert done == {src} + assert cached_file_data.st_mtime == st.st_mtime + + # Modify st_mtime + cached_file_data = cache.file_data[str(src)] = FileData( + cached_file_data.st_mtime - 1, + cached_file_data.st_size, + cached_file_data.hash, + ) + todo, done = cache.filtered_cached([src]) + assert todo == set() + assert done == {src} + assert cached_file_data.st_mtime < st.st_mtime + assert cached_file_data.st_size == st.st_size + assert cached_file_data.hash == black.Cache.hash_digest(src) + + # Modify contents + src.write_text("print('hello world')", encoding="utf-8") + new_st = src.stat() + todo, done = cache.filtered_cached([src]) + assert todo == {src} + assert done == set() + assert cached_file_data.st_mtime < new_st.st_mtime + assert cached_file_data.st_size != new_st.st_size + assert cached_file_data.hash != black.Cache.hash_digest(src) + + def test_write_cache_creates_directory_if_needed(self) -> None: + mode = DEFAULT_MODE + with cache_dir(exists=False) as workspace: + assert not workspace.exists() + cache = black.Cache.read(mode) + cache.write([]) + assert workspace.exists() + + @event_loop() + def test_failed_formatting_does_not_get_cached(self) -> None: + mode = DEFAULT_MODE + with ( + cache_dir() as workspace, + patch("concurrent.futures.ProcessPoolExecutor", new=ThreadPoolExecutor), + ): + failing = (workspace / "failing.py").resolve() + failing.write_text("not actually python", encoding="utf-8") + clean = (workspace / "clean.py").resolve() + clean.write_text('print("hello")\n', encoding="utf-8") + invokeBlack([str(workspace)], exit_code=123) + cache = black.Cache.read(mode) + assert cache.is_changed(failing) + assert not cache.is_changed(clean) + + def test_write_cache_write_fail(self) -> None: + mode = DEFAULT_MODE + with cache_dir(): + cache = black.Cache.read(mode) + with patch.object(Path, "open") as mock: + mock.side_effect = OSError + cache.write([]) + + def test_read_cache_line_lengths(self) -> None: + mode = DEFAULT_MODE + short_mode = replace(DEFAULT_MODE, line_length=1) + with cache_dir() as workspace: + path = (workspace / "file.py").resolve() + path.touch() + cache = black.Cache.read(mode) + cache.write([path]) + one = black.Cache.read(mode) + assert not one.is_changed(path) + two = black.Cache.read(short_mode) + assert two.is_changed(path) + + def test_cache_key(self) -> None: + # Test that all members of the mode enum affect the cache key. + for field in fields(Mode): + values: list[Any] + if field.name == "target_versions": + values = [ + {TargetVersion.PY312}, + {TargetVersion.PY313}, + ] + elif field.name == "python_cell_magics": + values = [{"magic1"}, {"magic2"}] + elif field.name == "enabled_features": + # If you are looking to remove one of these features, just + # replace it with any other feature. + values = [ + {Preview.wrap_comprehension_in}, + {Preview.string_processing}, + ] + elif field.type is bool: + values = [True, False] + elif field.type is int: + values = [1, 2] + else: + raise AssertionError( + f"Unhandled field type: {field.type} for field {field.name}" + ) + modes = [replace(DEFAULT_MODE, **{field.name: value}) for value in values] + keys = [mode.get_cache_key() for mode in modes] + assert len(set(keys)) == len(modes) + + +def assert_collected_sources( + src: Sequence[str | Path], + expected: Sequence[str | Path], + *, + root: Path | None = None, + exclude: str | None = None, + include: str | None = None, + extend_exclude: str | None = None, + force_exclude: str | None = None, + stdin_filename: str | None = None, +) -> None: + gs_src = tuple(str(Path(s)) for s in src) + gs_expected = [Path(s) for s in expected] + gs_exclude = None if exclude is None else compile_pattern(exclude) + gs_include = DEFAULT_INCLUDE if include is None else compile_pattern(include) + gs_extend_exclude = ( + None if extend_exclude is None else compile_pattern(extend_exclude) + ) + gs_force_exclude = None if force_exclude is None else compile_pattern(force_exclude) + collected = black.get_sources( + root=root or THIS_DIR, + src=gs_src, + quiet=False, + verbose=False, + include=gs_include, + exclude=gs_exclude, + extend_exclude=gs_extend_exclude, + force_exclude=gs_force_exclude, + report=black.Report(), + stdin_filename=stdin_filename, + ) + assert sorted(collected) == sorted(gs_expected) + + +class TestFileCollection: + def test_include_exclude(self) -> None: + path = THIS_DIR / "data" / "include_exclude_tests" + src = [path] + expected = [ + Path(path / "b/dont_exclude/a.py"), + Path(path / "b/dont_exclude/a.pyi"), + ] + assert_collected_sources( + src, + expected, + include=r"\.pyi?$", + exclude=r"/exclude/|/\.definitely_exclude/", + ) + + def test_gitignore_used_as_default(self) -> None: + base = Path(DATA_DIR / "include_exclude_tests") + expected = [ + base / "b/.definitely_exclude/a.py", + base / "b/.definitely_exclude/a.pyi", + ] + src = [base / "b/"] + assert_collected_sources(src, expected, root=base, extend_exclude=r"/exclude/") + + def test_gitignore_used_on_multiple_sources(self) -> None: + root = Path(DATA_DIR / "gitignore_used_on_multiple_sources") + expected = [ + root / "dir1" / "b.py", + root / "dir2" / "b.py", + ] + src = [root / "dir1", root / "dir2"] + assert_collected_sources(src, expected, root=root) + + @patch("black.find_project_root", lambda *args: (THIS_DIR.resolve(), None)) + def test_exclude_for_issue_1572(self) -> None: + # Exclude shouldn't touch files that were explicitly given to Black through the + # CLI. Exclude is supposed to only apply to the recursive discovery of files. + # https://github.com/psf/black/issues/1572 + path = DATA_DIR / "include_exclude_tests" + src = [path / "b/exclude/a.py"] + expected = [path / "b/exclude/a.py"] + assert_collected_sources(src, expected, include="", exclude=r"/exclude/|a\.py") + + def test_gitignore_exclude(self) -> None: + path = THIS_DIR / "data" / "include_exclude_tests" + include = re.compile(r"\.pyi?$") + exclude = re.compile(r"") + report = black.Report() + gitignore = GitIgnoreSpec.from_lines( + ["exclude/", ".definitely_exclude", "!exclude/still_exclude/"] + ) + sources: list[Path] = [] + expected = [ + Path(path / "b/dont_exclude/a.py"), + Path(path / "b/dont_exclude/a.pyi"), + ] + this_abs = THIS_DIR.resolve() + sources.extend( + black.gen_python_files( + path.iterdir(), + this_abs, + include, + exclude, + None, + None, + report, + {path: gitignore}, + verbose=False, + quiet=False, + ) + ) + assert sorted(expected) == sorted(sources) + + def test_gitignore_reinclude(self) -> None: + path = THIS_DIR / "data" / "include_exclude_tests" + include = re.compile(r"\.pyi?$") + exclude = re.compile(r"") + report = black.Report() + gitignore = GitIgnoreSpec.from_lines( + ["*/exclude/*", ".definitely_exclude", "!*/exclude/still_exclude/"] + ) + sources: list[Path] = [] + expected = [ + Path(path / "b/dont_exclude/a.py"), + Path(path / "b/dont_exclude/a.pyi"), + Path(path / "b/exclude/still_exclude/a.py"), + Path(path / "b/exclude/still_exclude/a.pyi"), + ] + this_abs = THIS_DIR.resolve() + sources.extend( + black.gen_python_files( + path.iterdir(), + this_abs, + include, + exclude, + None, + None, + report, + {path: gitignore}, + verbose=False, + quiet=False, + ) + ) + assert sorted(expected) == sorted(sources) + + def test_gitignore_reinclude_root(self) -> None: + path = THIS_DIR / "data" / "include_exclude_tests" / "b" + include = re.compile(r"\.pyi?$") + exclude = re.compile(r"") + report = black.Report() + gitignore = GitIgnoreSpec.from_lines( + ["exclude/*", ".definitely_exclude", "!exclude/still_exclude/"] + ) + sources: list[Path] = [] + expected = [ + Path(path / "dont_exclude/a.py"), + Path(path / "dont_exclude/a.pyi"), + Path(path / "exclude/still_exclude/a.py"), + Path(path / "exclude/still_exclude/a.pyi"), + ] + this_abs = THIS_DIR.resolve() + sources.extend( + black.gen_python_files( + path.iterdir(), + this_abs, + include, + exclude, + None, + None, + report, + {path: gitignore}, + verbose=False, + quiet=False, + ) + ) + assert sorted(expected) == sorted(sources) + + def test_nested_gitignore(self) -> None: + path = Path(THIS_DIR / "data" / "nested_gitignore_tests") + include = re.compile(r"\.pyi?$") + exclude = re.compile(r"") + root_gitignore = black.files.get_gitignore(path) + report = black.Report() + expected: list[Path] = [ + Path(path / "x.py"), + Path(path / "root/b.py"), + Path(path / "root/c.py"), + Path(path / "root/child/c.py"), + ] + this_abs = THIS_DIR.resolve() + sources = list( + black.gen_python_files( + path.iterdir(), + this_abs, + include, + exclude, + None, + None, + report, + {path: root_gitignore}, + verbose=False, + quiet=False, + ) + ) + assert sorted(expected) == sorted(sources) + + def test_nested_gitignore_directly_in_source_directory(self) -> None: + # https://github.com/psf/black/issues/2598 + path = Path(DATA_DIR / "nested_gitignore_tests") + src = Path(path / "root" / "child") + expected = [src / "a.py", src / "c.py"] + assert_collected_sources([src], expected) + + def test_invalid_gitignore(self) -> None: + path = THIS_DIR / "data" / "invalid_gitignore_tests" + empty_config = path / "pyproject.toml" + result = BlackRunner().invoke( + black.main, ["--verbose", "--config", str(empty_config), str(path)] + ) + assert result.exit_code == 1 + assert result.stderr_bytes is not None + + gitignore = path / ".gitignore" + assert re.search( + f"Could not parse {gitignore}".replace("\\", "\\\\"), + result.stderr_bytes.decode(), + re.IGNORECASE if isinstance(gitignore, WindowsPath) else 0, + ) + + def test_invalid_nested_gitignore(self) -> None: + path = THIS_DIR / "data" / "invalid_nested_gitignore_tests" + empty_config = path / "pyproject.toml" + result = BlackRunner().invoke( + black.main, ["--verbose", "--config", str(empty_config), str(path)] + ) + assert result.exit_code == 1 + assert result.stderr_bytes is not None + + gitignore = path / "a" / ".gitignore" + assert re.search( + f"Could not parse {gitignore}".replace("\\", "\\\\"), + result.stderr_bytes.decode(), + re.IGNORECASE if isinstance(gitignore, WindowsPath) else 0, + ) + + def test_gitignore_that_ignores_subfolders(self) -> None: + # If gitignore with */* is in root + root = Path(DATA_DIR / "ignore_subfolders_gitignore_tests" / "subdir") + expected = [root / "b.py"] + assert_collected_sources([root], expected, root=root) + + # If .gitignore with */* is nested + root = Path(DATA_DIR / "ignore_subfolders_gitignore_tests") + expected = [ + root / "a.py", + root / "subdir" / "b.py", + ] + assert_collected_sources([root], expected, root=root) + + # If command is executed from outer dir + root = Path(DATA_DIR / "ignore_subfolders_gitignore_tests") + target = root / "subdir" + expected = [target / "b.py"] + assert_collected_sources([target], expected, root=root) + + def test_gitignore_that_ignores_directory(self) -> None: + # If gitignore with a directory is in root + root = Path(DATA_DIR, "ignore_directory_gitignore_tests") + expected = [root / "z.py"] + assert_collected_sources([root], expected, root=root) + + def test_empty_include(self) -> None: + path = DATA_DIR / "include_exclude_tests" + src = [path] + expected = [ + Path(path / "b/exclude/a.pie"), + Path(path / "b/exclude/a.py"), + Path(path / "b/exclude/a.pyi"), + Path(path / "b/exclude/still_exclude/a.pie"), + Path(path / "b/exclude/still_exclude/a.py"), + Path(path / "b/exclude/still_exclude/a.pyi"), + Path(path / "b/dont_exclude/a.pie"), + Path(path / "b/dont_exclude/a.py"), + Path(path / "b/dont_exclude/a.pyi"), + Path(path / "b/.definitely_exclude/a.pie"), + Path(path / "b/.definitely_exclude/a.py"), + Path(path / "b/.definitely_exclude/a.pyi"), + Path(path / ".gitignore"), + Path(path / "pyproject.toml"), + ] + # Setting exclude explicitly to an empty string to block .gitignore usage. + assert_collected_sources(src, expected, include="", exclude="") + + def test_include_absolute_path(self) -> None: + path = DATA_DIR / "include_exclude_tests" + src = [path] + expected = [ + Path(path / "b/dont_exclude/a.pie"), + ] + assert_collected_sources( + src, expected, root=path, include=r"^/b/dont_exclude/a\.pie$", exclude="" + ) + + def test_exclude_absolute_path(self) -> None: + path = DATA_DIR / "include_exclude_tests" + src = [path] + expected = [ + Path(path / "b/dont_exclude/a.py"), + Path(path / "b/exclude/still_exclude/a.py"), + Path(path / "b/.definitely_exclude/a.py"), + ] + assert_collected_sources( + src, expected, root=path, include=r"\.py$", exclude=r"^/b/exclude/a\.py$" + ) + + def test_extend_exclude(self) -> None: + path = DATA_DIR / "include_exclude_tests" + src = [path] + expected = [ + Path(path / "b/exclude/a.py"), + Path(path / "b/exclude/still_exclude/a.py"), + Path(path / "b/dont_exclude/a.py"), + ] + assert_collected_sources( + src, expected, exclude=r"\.pyi$", extend_exclude=r"\.definitely_exclude" + ) + + @pytest.mark.incompatible_with_mypyc + def test_symlinks(self) -> None: + root = THIS_DIR.resolve() + include = re.compile(black.DEFAULT_INCLUDES) + exclude = re.compile(black.DEFAULT_EXCLUDES) + report = black.Report() + gitignore = GitIgnoreSpec.from_lines([]) + + regular = MagicMock() + regular.relative_to.return_value = Path("regular.py") + regular.resolve.return_value = root / "regular.py" + regular.is_dir.return_value = False + regular.is_file.return_value = True + + outside_root_symlink = MagicMock() + outside_root_symlink.relative_to.return_value = Path("symlink.py") + outside_root_symlink.resolve.return_value = Path("/nowhere") + outside_root_symlink.is_dir.return_value = False + outside_root_symlink.is_file.return_value = True + + ignored_symlink = MagicMock() + ignored_symlink.relative_to.return_value = Path(".mypy_cache") / "symlink.py" + ignored_symlink.is_dir.return_value = False + ignored_symlink.is_file.return_value = True + + # A symlink that has an excluded name, but points to an included name + symlink_excluded_name = MagicMock() + symlink_excluded_name.relative_to.return_value = Path("excluded_name") + symlink_excluded_name.resolve.return_value = root / "included_name.py" + symlink_excluded_name.is_dir.return_value = False + symlink_excluded_name.is_file.return_value = True + + # A symlink that has an included name, but points to an excluded name + symlink_included_name = MagicMock() + symlink_included_name.relative_to.return_value = Path("included_name.py") + symlink_included_name.resolve.return_value = root / "excluded_name" + symlink_included_name.is_dir.return_value = False + symlink_included_name.is_file.return_value = True + + path = MagicMock() + path.iterdir.return_value = [ + regular, + outside_root_symlink, + ignored_symlink, + symlink_excluded_name, + symlink_included_name, + ] + + files = list( + black.gen_python_files( + path.iterdir(), + root, + include, + exclude, + None, + None, + report, + {path: gitignore}, + verbose=False, + quiet=False, + ) + ) + assert files == [regular, symlink_included_name] + + path.iterdir.assert_called_once() + outside_root_symlink.resolve.assert_called_once() + ignored_symlink.resolve.assert_not_called() + + def test_get_sources_symlink_and_force_exclude(self) -> None: + with TemporaryDirectory() as tempdir: + tmp = Path(tempdir).resolve() + actual = tmp / "actual" + actual.mkdir() + symlink = tmp / "symlink" + symlink.symlink_to(actual) + + actual_proj = actual / "project" + actual_proj.mkdir() + (actual_proj / "module.py").write_text("print('hello')", encoding="utf-8") + + symlink_proj = symlink / "project" + + with change_directory(symlink_proj): + assert_collected_sources( + src=["module.py"], + root=symlink_proj.resolve(), + expected=["module.py"], + ) + + absolute_module = symlink_proj / "module.py" + assert_collected_sources( + src=[absolute_module], + root=symlink_proj.resolve(), + expected=[absolute_module], + ) + + # a few tricky tests for force_exclude + flat_symlink = symlink_proj / "symlink_module.py" + flat_symlink.symlink_to(actual_proj / "module.py") + assert_collected_sources( + src=[flat_symlink], + root=symlink_proj.resolve(), + force_exclude=r"/symlink_module.py", + expected=[], + ) + + target = actual_proj / "target" + target.mkdir() + (target / "another.py").write_text("print('hello')", encoding="utf-8") + (symlink_proj / "nested").symlink_to(target) + + assert_collected_sources( + src=[symlink_proj / "nested" / "another.py"], + root=symlink_proj.resolve(), + force_exclude=r"nested", + expected=[], + ) + assert_collected_sources( + src=[symlink_proj / "nested" / "another.py"], + root=symlink_proj.resolve(), + force_exclude=r"target", + expected=[symlink_proj / "nested" / "another.py"], + ) + + def test_get_sources_with_stdin_symlink_outside_root( + self, + ) -> None: + with TemporaryDirectory() as tempdir: + tmp = Path(tempdir).resolve() + + root = tmp / "root" + root.mkdir() + (root / "pyproject.toml").write_text("[tool.black]", encoding="utf-8") + + target = tmp / "outside_root" / "a.py" + target.parent.mkdir() + target.write_text("print('hello')", encoding="utf-8") + (root / "a.py").symlink_to(target) + + stdin_filename = str(root / "a.py") + assert_collected_sources( + root=root, + src=["-"], + expected=[], + stdin_filename=stdin_filename, + ) + + def test_get_sources_with_stdin(self) -> None: + src = ["-"] + expected = ["-"] + assert_collected_sources( + src, + root=THIS_DIR.resolve(), + expected=expected, + include="", + exclude=r"/exclude/|a\.py", + ) + + def test_get_sources_with_stdin_filename(self) -> None: + src = ["-"] + stdin_filename = str(THIS_DIR / "data/collections.py") + expected = [f"__BLACK_STDIN_FILENAME__{stdin_filename}"] + assert_collected_sources( + src, + root=THIS_DIR.resolve(), + expected=expected, + exclude=r"/exclude/a\.py", + stdin_filename=stdin_filename, + ) + + def test_get_sources_with_stdin_filename_and_exclude(self) -> None: + # Exclude shouldn't exclude stdin_filename since it is mimicking the + # file being passed directly. This is the same as + # test_exclude_for_issue_1572 + path = DATA_DIR / "include_exclude_tests" + src = ["-"] + stdin_filename = str(path / "b/exclude/a.py") + expected = [f"__BLACK_STDIN_FILENAME__{stdin_filename}"] + assert_collected_sources( + src, + root=THIS_DIR.resolve(), + expected=expected, + exclude=r"/exclude/|a\.py", + stdin_filename=stdin_filename, + ) + + def test_get_sources_with_stdin_filename_and_extend_exclude(self) -> None: + # Extend exclude shouldn't exclude stdin_filename since it is mimicking the + # file being passed directly. This is the same as + # test_exclude_for_issue_1572 + src = ["-"] + path = THIS_DIR / "data" / "include_exclude_tests" + stdin_filename = str(path / "b/exclude/a.py") + expected = [f"__BLACK_STDIN_FILENAME__{stdin_filename}"] + assert_collected_sources( + src, + root=THIS_DIR.resolve(), + expected=expected, + extend_exclude=r"/exclude/|a\.py", + stdin_filename=stdin_filename, + ) + + def test_get_sources_with_stdin_filename_and_force_exclude(self) -> None: + # Force exclude should exclude the file when passing it through + # stdin_filename + path = THIS_DIR / "data" / "include_exclude_tests" + stdin_filename = str(path / "b/exclude/a.py") + assert_collected_sources( + src=["-"], + root=THIS_DIR.resolve(), + expected=[], + force_exclude=r"/exclude/|a\.py", + stdin_filename=stdin_filename, + ) + + def test_get_sources_with_stdin_filename_and_force_exclude_and_symlink( + self, + ) -> None: + # Force exclude should exclude a symlink based on the symlink, not its target + with TemporaryDirectory() as tempdir: + tmp = Path(tempdir).resolve() + (tmp / "exclude").mkdir() + (tmp / "exclude" / "a.py").write_text("print('hello')", encoding="utf-8") + (tmp / "symlink.py").symlink_to(tmp / "exclude" / "a.py") + + stdin_filename = str(tmp / "symlink.py") + expected = [f"__BLACK_STDIN_FILENAME__{stdin_filename}"] + with change_directory(tmp): + assert_collected_sources( + src=["-"], + root=tmp, + expected=expected, + force_exclude=r"exclude/a\.py", + stdin_filename=stdin_filename, + ) + + +class TestDeFactoAPI: + """Test that certain symbols that are commonly used externally keep working. + + We don't (yet) formally expose an API (see issue #779), but we should endeavor to + keep certain functions that external users commonly rely on working. + + """ + + def test_format_str(self) -> None: + # format_str and Mode should keep working + assert ( + black.format_str("print('hello')", mode=black.Mode()) == 'print("hello")\n' + ) + + # you can pass line length + assert ( + black.format_str("print('hello')", mode=black.Mode(line_length=42)) + == 'print("hello")\n' + ) + + # invalid input raises InvalidInput + with pytest.raises(black.InvalidInput): + black.format_str("syntax error", mode=black.Mode()) + + def test_format_file_contents(self) -> None: + # You probably should be using format_str() instead, but let's keep + # this one around since people do use it + assert ( + black.format_file_contents("x=1", fast=True, mode=black.Mode()) == "x = 1\n" + ) + + with pytest.raises(black.NothingChanged): + black.format_file_contents("x = 1\n", fast=True, mode=black.Mode()) + + +class TestASTSafety(BlackBaseTestCase): + def check_ast_equivalence( + self, source: str, dest: str, *, should_fail: bool = False + ) -> None: + # If we get a failure, make sure it's not because the code itself + # is invalid, since that will also cause assert_equivalent() to throw + # ASTSafetyError. + source = textwrap.dedent(source) + dest = textwrap.dedent(dest) + black.parse_ast(source) + black.parse_ast(dest) + if should_fail: + with self.assertRaises(ASTSafetyError): + black.assert_equivalent(source, dest) + else: + black.assert_equivalent(source, dest) + + def test_assert_equivalent_basic(self) -> None: + self.check_ast_equivalence("{}", "None", should_fail=True) + self.check_ast_equivalence("1+2", "1 + 2") + self.check_ast_equivalence("hi # comment", "hi") + + def test_assert_equivalent_del(self) -> None: + self.check_ast_equivalence("del (a, b)", "del a, b") + + def test_assert_equivalent_strings(self) -> None: + self.check_ast_equivalence('x = "x"', 'x = " x "', should_fail=True) + self.check_ast_equivalence( + ''' + """docstring """ + ''', + ''' + """docstring""" + ''', + ) + self.check_ast_equivalence( + ''' + """docstring """ + ''', + ''' + """ddocstring""" + ''', + should_fail=True, + ) + self.check_ast_equivalence( + ''' + class A: + """ + + docstring + + + """ + ''', + ''' + class A: + """docstring""" + ''', + ) + self.check_ast_equivalence( + """ + def f(): + " docstring " + """, + ''' + def f(): + """docstring""" + ''', + ) + self.check_ast_equivalence( + """ + async def f(): + " docstring " + """, + ''' + async def f(): + """docstring""" + ''', + ) + self.check_ast_equivalence( + """ + if __name__ == "__main__": + " docstring-like " + """, + ''' + if __name__ == "__main__": + """docstring-like""" + ''', + ) + self.check_ast_equivalence(r'def f(): r" \n "', r'def f(): "\\n"') + self.check_ast_equivalence('try: pass\nexcept: " x "', 'try: pass\nexcept: "x"') + + self.check_ast_equivalence( + 'def foo(): return " x "', 'def foo(): return "x"', should_fail=True + ) + + def test_assert_equivalent_fstring(self) -> None: + major, minor = sys.version_info[:2] + if major < 3 or (major == 3 and minor < 12): + pytest.skip("relies on 3.12+ syntax") + # https://github.com/psf/black/issues/4268 + self.check_ast_equivalence( + """print(f"{"|".join([a,b,c])}")""", + """print(f"{" | ".join([a,b,c])}")""", + should_fail=True, + ) + self.check_ast_equivalence( + """print(f"{"|".join(['a','b','c'])}")""", + """print(f"{" | ".join(['a','b','c'])}")""", + should_fail=True, + ) + + def test_equivalency_ast_parse_failure_includes_error(self) -> None: + with pytest.raises(SourceASTParseError) as err: + black.assert_equivalent("a«»a = 1", "a«»a = 1") + + err.match("--safe") + # Unfortunately the SyntaxError message has changed in newer versions so we + # can't match it directly. + err.match("invalid character") + err.match(r"\(, line 1\)") + + def test_target_version_exceeds_runtime_warning(self) -> None: + max_target = max(TargetVersion, key=lambda tv: tv.value) + if sys.version_info[1] >= max_target.value: + pytest.skip("no target version higher than runtime available") + target_name = f"py3{sys.version_info[1] + 1}" + code = "x = 1\n" + args = ["--target-version", target_name, "--code", code] + result = BlackRunner().invoke(black.main, args) + stderr = result.stderr_bytes.decode() if result.stderr_bytes else "" + assert "Warning:" in stderr + + def test_target_version_exceeds_runtime_no_warning_with_fast(self) -> None: + max_target = max(TargetVersion, key=lambda tv: tv.value) + if sys.version_info[1] >= max_target.value: + pytest.skip("no target version higher than runtime available") + target_name = f"py3{sys.version_info[1] + 1}" + code = "x = 1\n" + args = ["--fast", "--target-version", target_name, "--code", code] + result = BlackRunner().invoke(black.main, args) + stderr = result.stderr_bytes.decode() if result.stderr_bytes else "" + assert "Warning:" not in stderr + + def test_target_version_at_runtime_no_warning(self) -> None: + current_minor = sys.version_info[1] + target_name = f"py3{current_minor}" + code = "x = 1\n" + args = ["--target-version", target_name, "--code", code] + result = BlackRunner().invoke(black.main, args) + stderr = result.stderr_bytes.decode() if result.stderr_bytes else "" + assert "Warning:" not in stderr + + def test_mixed_target_versions_with_runtime_no_warning(self) -> None: + """Regression test for #5164: no spurious warning when target includes + the runtime version alongside higher versions.""" + current_minor = sys.version_info[1] + higher_target = f"py3{current_minor + 1}" + runtime_target = f"py3{current_minor}" + code = "x = 1\n" + args = [ + "--target-version", + runtime_target, + "--target-version", + higher_target, + "--code", + code, + ] + result = BlackRunner().invoke(black.main, args) + stderr = result.stderr_bytes.decode() if result.stderr_bytes else "" + assert "Warning:" not in stderr + + @pytest.mark.incompatible_with_mypyc + def test_target_version_exceeds_runtime_clear_error_message(self) -> None: + max_target = max(TargetVersion, key=lambda tv: tv.value) + if sys.version_info[1] >= max_target.value: + pytest.skip("no target version higher than runtime available") + future_target = TargetVersion[f"PY3{sys.version_info[1] + 1}"] + mode = Mode(target_versions={future_target}) + with patch.object( + black, + "assert_equivalent", + side_effect=ASTSafetyError("mocked parse failure"), + ): + with pytest.raises(ASTSafetyError) as exc_info: + black.check_stability_and_equivalence("x = 1\n", "x = 1\n", mode=mode) + assert "INTERNAL ERROR" not in str(exc_info.value) + + +try: + with open(black.__file__, encoding="utf-8") as _bf: + black_source_lines = _bf.readlines() +except UnicodeDecodeError: + if not black.COMPILED: + raise + + +def tracefunc( + frame: types.FrameType, event: str, arg: Any +) -> Callable[[types.FrameType, str, Any], Any]: + """Show function calls `from black/__init__.py` as they happen. + + Register this with `sys.settrace()` in a test you're debugging. + """ + if event != "call": + return tracefunc + + stack = len(inspect.stack()) - 19 + stack *= 2 + filename = frame.f_code.co_filename + lineno = frame.f_lineno + func_sig_lineno = lineno - 1 + funcname = black_source_lines[func_sig_lineno].strip() + while funcname.startswith("@"): + func_sig_lineno += 1 + funcname = black_source_lines[func_sig_lineno].strip() + if "black/__init__.py" in filename: + print(f"{' ' * stack}{lineno}:{funcname}") + return tracefunc diff --git a/tests/test_blackd.py b/tests/test_blackd.py new file mode 100644 index 0000000..3030ee9 --- /dev/null +++ b/tests/test_blackd.py @@ -0,0 +1,449 @@ +import asyncio +import gc +import re +from concurrent.futures import ThreadPoolExecutor +from datetime import datetime, timezone +from threading import Event +from unittest.mock import patch + +import pytest +from click.testing import CliRunner + +from tests.util import DETERMINISTIC_HEADER, read_data + +try: + from aiohttp import web + from aiohttp.test_utils import AioHTTPTestCase + + import blackd + import blackd.client +except ImportError as e: + raise RuntimeError("Please install Black with the 'd' extra") from e + +import black + + +@pytest.mark.blackd +class BlackDTestCase(AioHTTPTestCase): + def tearDown(self) -> None: + # Work around https://github.com/python/cpython/issues/124706 + gc.collect() + super().tearDown() + + def test_blackd_main(self) -> None: + with patch("blackd.web.run_app"): + result = CliRunner().invoke(blackd.main, []) + if result.exception is not None: + raise result.exception + self.assertEqual(result.exit_code, 0) + + async def get_application(self) -> web.Application: + return blackd.make_app() + + async def test_blackd_request_needs_formatting(self) -> None: + response = await self.client.post("/", data=b"print('hello world')") + self.assertEqual(response.status, 200) + self.assertEqual(response.charset, "utf8") + self.assertEqual(await response.read(), b'print("hello world")\n') + + async def test_blackd_request_no_change(self) -> None: + response = await self.client.post("/", data=b'print("hello world")\n') + self.assertEqual(response.status, 204) + self.assertEqual(await response.read(), b"") + + async def test_blackd_request_syntax_error(self) -> None: + response = await self.client.post("/", data=b"what even ( is") + self.assertEqual(response.status, 400) + content = await response.text() + self.assertTrue( + content.startswith("Cannot parse"), + msg=f"Expected error to start with 'Cannot parse', got {repr(content)}", + ) + + async def test_blackd_unsupported_version(self) -> None: + response = await self.client.post( + "/", data=b"what", headers={blackd.PROTOCOL_VERSION_HEADER: "2"} + ) + self.assertEqual(response.status, 501) + + async def test_blackd_supported_version(self) -> None: + response = await self.client.post( + "/", data=b"what", headers={blackd.PROTOCOL_VERSION_HEADER: "1"} + ) + self.assertEqual(response.status, 200) + + async def test_blackd_invalid_python_variant(self) -> None: + async def check(header_value: str, expected_status: int = 400) -> None: + response = await self.client.post( + "/", + data=b"what", + headers={blackd.PYTHON_VARIANT_HEADER: header_value}, + ) + self.assertEqual(response.status, expected_status) + + await check("lol") + await check("ruby3.5") + await check("pyi3.6") + await check("py1.5") + await check("2") + await check("2.7") + await check("py2.7") + await check("2.8") + await check("py2.8") + await check("3.0") + await check("pypy3.0") + await check("jython3.4") + + async def test_blackd_pyi(self) -> None: + source, expected = read_data("cases", "stub.py") + response = await self.client.post( + "/", data=source, headers={blackd.PYTHON_VARIANT_HEADER: "pyi"} + ) + self.assertEqual(response.status, 200) + self.assertEqual(await response.text(), expected) + + async def test_blackd_diff(self) -> None: + diff_header = re.compile( + r"(In|Out)\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d\.\d\d\d\d\d\d\+\d\d:\d\d" + ) + + source, _ = read_data("miscellaneous", "blackd_diff") + expected, _ = read_data("miscellaneous", "blackd_diff.diff") + + response = await self.client.post( + "/", data=source, headers={blackd.DIFF_HEADER: "true"} + ) + self.assertEqual(response.status, 200) + + actual = await response.text() + actual = diff_header.sub(DETERMINISTIC_HEADER, actual) + self.assertEqual(actual, expected) + + async def test_blackd_python_variant(self) -> None: + code = ( + "def f(\n" + " and_has_a_bunch_of,\n" + " very_long_arguments_too,\n" + " and_lots_of_them_as_well_lol,\n" + " **and_very_long_keyword_arguments\n" + "):\n" + " pass\n" + ) + + async def check(header_value: str, expected_status: int) -> None: + response = await self.client.post( + "/", data=code, headers={blackd.PYTHON_VARIANT_HEADER: header_value} + ) + self.assertEqual( + response.status, expected_status, msg=await response.text() + ) + + await check("3.6", 200) + await check("py3.6", 200) + await check("3.6,3.7", 200) + await check("3.6,py3.7", 200) + await check("py36,py37", 200) + await check("36", 200) + await check("3.6.4", 200) + await check("3.4", 204) + await check("py3.4", 204) + await check("py34,py36", 204) + await check("34", 204) + + async def test_blackd_line_length(self) -> None: + response = await self.client.post( + "/", data=b'print("hello")\n', headers={blackd.LINE_LENGTH_HEADER: "7"} + ) + self.assertEqual(response.status, 200) + + async def test_blackd_invalid_line_length(self) -> None: + response = await self.client.post( + "/", + data=b'print("hello")\n', + headers={blackd.LINE_LENGTH_HEADER: "NaN"}, + ) + self.assertEqual(response.status, 400) + + async def test_blackd_skip_first_source_line(self) -> None: + invalid_first_line = b"Header will be skipped\r\ni = [1,2,3]\nj = [1,2,3]\n" + expected_result = b"Header will be skipped\r\ni = [1, 2, 3]\nj = [1, 2, 3]\n" + response = await self.client.post("/", data=invalid_first_line) + self.assertEqual(response.status, 400) + response = await self.client.post( + "/", + data=invalid_first_line, + headers={blackd.SKIP_SOURCE_FIRST_LINE: "true"}, + ) + self.assertEqual(response.status, 200) + self.assertEqual(await response.read(), expected_result) + + async def test_blackd_preview(self) -> None: + response = await self.client.post( + "/", data=b'print("hello")\n', headers={blackd.PREVIEW: "true"} + ) + self.assertEqual(response.status, 204) + + async def test_blackd_response_black_version_header(self) -> None: + response = await self.client.post("/") + self.assertIsNotNone(response.headers.get(blackd.BLACK_VERSION_HEADER)) + + async def test_cors_preflight(self) -> None: + response = await self.client.options( + "/", + headers={ + "Access-Control-Request-Method": "POST", + "Origin": "https://example.com", + "Access-Control-Request-Headers": "Content-Type", + }, + ) + self.assertEqual(response.status, 403) + self.assertIsNone(response.headers.get("Access-Control-Allow-Origin")) + self.assertIsNone(response.headers.get("Access-Control-Allow-Headers")) + self.assertIsNone(response.headers.get("Access-Control-Allow-Methods")) + + async def test_cors_requests_rejected_by_default(self) -> None: + response = await self.client.post( + "/", headers={"Origin": "https://example.com"} + ) + self.assertEqual(response.status, 403) + self.assertIsNone(response.headers.get("Access-Control-Allow-Origin")) + self.assertIsNone(response.headers.get("Access-Control-Expose-Headers")) + + async def test_blackd_format_code_limits_executor_queue(self) -> None: + started = Event() + release = Event() + calls: list[str] = [] + executor = ThreadPoolExecutor(max_workers=2) + executor_semaphore = asyncio.BoundedSemaphore(1) + + def slow_format(src: str, *, fast: bool, mode: black.Mode) -> str: + calls.append(src) + started.set() + release.wait(timeout=1) + return src + + try: + with patch("blackd.black.format_file_contents", side_effect=slow_format): + task1 = asyncio.create_task( + blackd.format_code( + req_str="print(1)\n", + fast=False, + mode=black.Mode(), + then=datetime.now(timezone.utc), + only_diff=False, + executor=executor, + executor_semaphore=executor_semaphore, + ) + ) + + for _ in range(20): + if started.is_set(): + break + await asyncio.sleep(0.01) + self.assertTrue(started.is_set()) + + task2 = asyncio.create_task( + blackd.format_code( + req_str="print(2)\n", + fast=False, + mode=black.Mode(), + then=datetime.now(timezone.utc), + only_diff=False, + executor=executor, + executor_semaphore=executor_semaphore, + ) + ) + await asyncio.sleep(0.05) + self.assertEqual(len(calls), 1) + + release.set() + self.assertEqual(await task1, "print(1)\n") + self.assertEqual(await task2, "print(2)\n") + self.assertEqual(len(calls), 2) + finally: + executor.shutdown(wait=True) + + async def test_preserves_line_endings(self) -> None: + for data in (b"c\r\nc\r\n", b"l\nl\n"): + # test preserved newlines when reformatted + response = await self.client.post("/", data=data + b" ") + self.assertEqual(await response.text(), data.decode()) + # test 204 when no change + response = await self.client.post("/", data=data) + self.assertEqual(response.status, 204) + + async def test_normalizes_line_endings(self) -> None: + for data, expected in ((b"c\r\nc\n", "c\r\nc\r\n"), (b"l\nl\r\n", "l\nl\n")): + response = await self.client.post("/", data=data) + self.assertEqual(await response.text(), expected) + self.assertEqual(response.status, 200) + + async def test_single_character(self) -> None: + response = await self.client.post("/", data="1") + self.assertEqual(await response.text(), "1\n") + self.assertEqual(response.status, 200) + + +@pytest.mark.blackd +class BlackDConfiguredCorsTestCase(AioHTTPTestCase): + def tearDown(self) -> None: + gc.collect() + super().tearDown() + + async def get_application(self) -> web.Application: + return blackd.make_app(cors_allow_origins=("https://example.com",)) + + async def test_cors_preflight(self) -> None: + response = await self.client.options( + "/", + headers={ + "Access-Control-Request-Method": "POST", + "Origin": "https://example.com", + "Access-Control-Request-Headers": "Content-Type", + }, + ) + self.assertEqual(response.status, 200) + self.assertEqual( + response.headers.get("Access-Control-Allow-Origin"), + "https://example.com", + ) + self.assertIsNotNone(response.headers.get("Access-Control-Allow-Headers")) + self.assertIsNotNone(response.headers.get("Access-Control-Allow-Methods")) + + async def test_cors_headers_present(self) -> None: + response = await self.client.post( + "/", headers={"Origin": "https://example.com"} + ) + self.assertEqual( + response.headers.get("Access-Control-Allow-Origin"), + "https://example.com", + ) + self.assertIn( + blackd.BLACK_VERSION_HEADER, + response.headers.get("Access-Control-Expose-Headers", ""), + ) + + +@pytest.mark.blackd +class BlackDSmallBodyLimitTestCase(AioHTTPTestCase): + def tearDown(self) -> None: + gc.collect() + super().tearDown() + + async def get_application(self) -> web.Application: + return blackd.make_app(max_body_size=16) + + async def test_blackd_rejects_large_request_body(self) -> None: + response = await self.client.post("/", data=b"x" * 17) + self.assertEqual(response.status, 413) + + +@pytest.mark.blackd +class BlackDClientTestCase(AioHTTPTestCase): + def tearDown(self) -> None: + # Work around https://github.com/python/cpython/issues/124706 + gc.collect() + super().tearDown() + + async def get_application(self) -> web.Application: + return blackd.make_app() + + async def test_unformatted_code(self) -> None: + client = blackd.client.BlackDClient(self.client.make_url("/")) + unformatted_code = "def hello(): print('Hello, World!')" + expected = 'def hello():\n print("Hello, World!")\n' + formatted_code = await client.format_code(unformatted_code) + + self.assertEqual(formatted_code, expected) + + async def test_formatted_code(self) -> None: + client = blackd.client.BlackDClient(self.client.make_url("/")) + initial_code = 'def hello():\n print("Hello, World!")\n' + expected = 'def hello():\n print("Hello, World!")\n' + formatted_code = await client.format_code(initial_code) + + self.assertEqual(formatted_code, expected) + + async def test_line_length(self) -> None: + client = blackd.client.BlackDClient(self.client.make_url("/"), line_length=10) + unformatted_code = "def hello(): print('Hello, World!')" + expected = 'def hello():\n print(\n "Hello, World!"\n )\n' + formatted_code = await client.format_code(unformatted_code) + + self.assertEqual(formatted_code, expected) + + async def test_skip_source_first_line(self) -> None: + client = blackd.client.BlackDClient( + self.client.make_url("/"), skip_source_first_line=True + ) + invalid_first_line = "Header will be skipped\r\ni = [1,2,3]\nj = [1,2,3]\n" + expected_result = "Header will be skipped\r\ni = [1, 2, 3]\nj = [1, 2, 3]\n" + formatted_code = await client.format_code(invalid_first_line) + + self.assertEqual(formatted_code, expected_result) + + async def test_skip_string_normalization(self) -> None: + client = blackd.client.BlackDClient( + self.client.make_url("/"), skip_string_normalization=True + ) + unformatted_code = "def hello(): print('Hello, World!')" + expected = "def hello():\n print('Hello, World!')\n" + formatted_code = await client.format_code(unformatted_code) + + self.assertEqual(formatted_code, expected) + + async def test_skip_magic_trailing_comma(self) -> None: + client = blackd.client.BlackDClient( + self.client.make_url("/"), skip_magic_trailing_comma=True + ) + unformatted_code = "def hello(): print('Hello, World!')" + expected = 'def hello():\n print("Hello, World!")\n' + formatted_code = await client.format_code(unformatted_code) + + self.assertEqual(formatted_code, expected) + + async def test_preview(self) -> None: + client = blackd.client.BlackDClient(self.client.make_url("/"), preview=True) + unformatted_code = "def hello(): print('Hello, World!')" + expected = 'def hello():\n print("Hello, World!")\n' + formatted_code = await client.format_code(unformatted_code) + + self.assertEqual(formatted_code, expected) + + async def test_fast(self) -> None: + client = blackd.client.BlackDClient(self.client.make_url("/"), fast=True) + unformatted_code = "def hello(): print('Hello, World!')" + expected = 'def hello():\n print("Hello, World!")\n' + formatted_code = await client.format_code(unformatted_code) + + self.assertEqual(formatted_code, expected) + + async def test_python_variant(self) -> None: + client = blackd.client.BlackDClient( + self.client.make_url("/"), python_variant="3.6" + ) + unformatted_code = "def hello(): print('Hello, World!')" + expected = 'def hello():\n print("Hello, World!")\n' + formatted_code = await client.format_code(unformatted_code) + + self.assertEqual(formatted_code, expected) + + async def test_diff(self) -> None: + diff_header = re.compile( + r"(In|Out)\t\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d\.\d\d\d\d\d\d\+\d\d:\d\d" + ) + + client = blackd.client.BlackDClient(self.client.make_url("/"), diff=True) + source, _ = read_data("miscellaneous", "blackd_diff") + expected, _ = read_data("miscellaneous", "blackd_diff.diff") + + diff = await client.format_code(source) + diff = diff_header.sub(DETERMINISTIC_HEADER, diff) + + self.assertEqual(diff, expected) + + async def test_syntax_error(self) -> None: + client = blackd.client.BlackDClient(self.client.make_url("/")) + with_syntax_error = "def hello(): a 'Hello, World!'" + with self.assertRaises(black.InvalidInput): + _ = await client.format_code(with_syntax_error) diff --git a/tests/test_concurrency_manager_shutdown.py b/tests/test_concurrency_manager_shutdown.py new file mode 100644 index 0000000..18758da --- /dev/null +++ b/tests/test_concurrency_manager_shutdown.py @@ -0,0 +1,66 @@ +from __future__ import annotations + +import asyncio +from concurrent.futures import ThreadPoolExecutor +from pathlib import Path +from typing import Any, Optional + +import black.concurrency as concurrency +from black import Mode, WriteBack +from black.report import Report + + +class FakeManager: + shutdown_called: bool + + def __init__(self) -> None: + self.shutdown_called = False + + def Lock(self) -> object: + return object() + + def shutdown(self) -> None: + self.shutdown_called = True + + +def test_manager_shutdown_called_for_diff(monkeypatch: Any, tmp_path: Path) -> None: + """ + schedule_formatting() creates multiprocessing.Manager() for DIFF/COLOR_DIFF + and must shut it down deterministically. + """ + fake_manager = FakeManager() + + monkeypatch.setattr(concurrency, "Manager", lambda: fake_manager) + + def fake_format_file_in_place( + src: Path, + fast: bool, + mode: Mode, + write_back: WriteBack, + lock: Optional[object], + ) -> bool: + assert lock is not None + return False + + monkeypatch.setattr(concurrency, "format_file_in_place", fake_format_file_in_place) + + src = tmp_path / "a.py" + src.write_text("x=1\n", encoding="utf8") + + async def run() -> None: + loop = asyncio.get_running_loop() + with ThreadPoolExecutor(max_workers=1) as executor: + await concurrency.schedule_formatting( + sources={src}, + fast=False, + write_back=WriteBack.DIFF, + mode=Mode(), + report=Report(), + loop=loop, + executor=executor, + no_cache=True, + ) + + asyncio.run(run()) + + assert fake_manager.shutdown_called is True diff --git a/tests/test_docs.py b/tests/test_docs.py new file mode 100644 index 0000000..e09124a --- /dev/null +++ b/tests/test_docs.py @@ -0,0 +1,74 @@ +""" + +Test that the docs are up to date. + +""" + +import re +from collections.abc import Sequence +from itertools import islice +from pathlib import Path + +import pytest + +from black.mode import UNSTABLE_FEATURES, Preview + +DOCS_PATH = Path("docs/the_black_code_style/future_style.md") + + +def check_feature_list( + lines: Sequence[str], expected_feature_names: set[str], label: str +) -> str | None: + start_index = lines.index(f"(labels/{label}-features)=\n") + if start_index == -1: + return ( + f"Could not find the {label} features list in {DOCS_PATH}. Ensure the" + " preview-features label is present." + ) + num_blank_lines_seen = 0 + seen_preview_feature_names = set() + for line in islice(lines, start_index + 1, None): + if not line.strip(): + num_blank_lines_seen += 1 + if num_blank_lines_seen == 3: + break + continue + if line.startswith("- "): + match = re.search(r"^- `([a-z\d_]+)`", line) + if match: + seen_preview_feature_names.add(match.group(1)) + + if seen_preview_feature_names - expected_feature_names: + extra = ", ".join(sorted(seen_preview_feature_names - expected_feature_names)) + return ( + f"The following features should not be in the list of {label} features:" + f" {extra}. Please remove them from the {label}-features label in" + f" {DOCS_PATH}" + ) + elif expected_feature_names - seen_preview_feature_names: + missing = ", ".join(sorted(expected_feature_names - seen_preview_feature_names)) + return ( + f"The following features are missing from the list of {label} features:" + f" {missing}. Please document them under the {label}-features label in" + f" {DOCS_PATH}" + ) + else: + return None + + +def test_feature_lists_are_up_to_date() -> None: + repo_root = Path(__file__).parent.parent + if not (repo_root / "docs").exists(): + pytest.skip("docs not found") + with (repo_root / DOCS_PATH).open(encoding="utf-8") as f: + future_style = f.readlines() + preview_error = check_feature_list( + future_style, + {feature.name for feature in set(Preview) - UNSTABLE_FEATURES}, + "preview", + ) + assert preview_error is None, preview_error + unstable_error = check_feature_list( + future_style, {feature.name for feature in UNSTABLE_FEATURES}, "unstable" + ) + assert unstable_error is None, unstable_error diff --git a/tests/test_format.py b/tests/test_format.py new file mode 100644 index 0000000..2a9d628 --- /dev/null +++ b/tests/test_format.py @@ -0,0 +1,99 @@ +import re +from collections.abc import Iterator +from dataclasses import replace +from typing import Any +from unittest.mock import patch + +import pytest + +import black +from black.mode import TargetVersion +from tests.util import ( + all_data_cases, + assert_format, + dump_to_stderr, + read_data, + read_data_with_mode, +) + + +@pytest.fixture(autouse=True) +def patch_dump_to_file(request: Any) -> Iterator[None]: + with patch("black.dump_to_file", dump_to_stderr): + yield + + +def check_file(subdir: str, filename: str, *, data: bool = True) -> None: + args, source, expected = read_data_with_mode(subdir, filename, data=data) + assert_format( + source, + expected, + args.mode, + fast=args.fast, + minimum_version=args.minimum_version, + lines=args.lines, + no_preview_line_length_1=args.no_preview_line_length_1, + ) + if args.minimum_version is not None: + major, minor = args.minimum_version + target_version = TargetVersion[f"PY{major}{minor}"] + mode = replace(args.mode, target_versions={target_version}) + assert_format( + source, + expected, + mode, + fast=args.fast, + minimum_version=args.minimum_version, + lines=args.lines, + no_preview_line_length_1=args.no_preview_line_length_1, + ) + + +@pytest.mark.filterwarnings("ignore:invalid escape sequence.*:DeprecationWarning") +@pytest.mark.parametrize("filename", all_data_cases("cases")) +def test_simple_format(filename: str) -> None: + check_file("cases", filename) + + +@pytest.mark.parametrize("filename", all_data_cases("line_ranges_formatted")) +def test_line_ranges_line_by_line(filename: str) -> None: + args, source, expected = read_data_with_mode("line_ranges_formatted", filename) + assert ( + source == expected + ), "Test cases in line_ranges_formatted must already be formatted." + line_count = len(source.splitlines()) + for line in range(1, line_count + 1): + assert_format( + source, + expected, + args.mode, + fast=args.fast, + minimum_version=args.minimum_version, + lines=[(line, line)], + ) + + +# =============== # +# Unusual cases +# =============== # + + +def test_empty() -> None: + source = expected = "" + assert_format(source, expected) + + +def test_patma_invalid() -> None: + source, expected = read_data("miscellaneous", "pattern_matching_invalid") + mode = black.Mode(target_versions={black.TargetVersion.PY310}) + with pytest.raises(black.parsing.InvalidInput) as exc_info: + assert_format(source, expected, mode, minimum_version=(3, 10)) + + exc_info.match( + re.escape( + "Cannot parse for target version Python 3.10: 10:11\n" + " case a := b:\n" + " ^\n" + "ParseError: bad input" + ) + ) diff --git a/tests/test_ipynb.py b/tests/test_ipynb.py new file mode 100644 index 0000000..aadf705 --- /dev/null +++ b/tests/test_ipynb.py @@ -0,0 +1,565 @@ +import contextlib +import pathlib +import re +from contextlib import AbstractContextManager +from contextlib import ExitStack as does_not_raise +from dataclasses import replace + +import pytest +from click.testing import CliRunner +from pytest import MonkeyPatch + +from black import ( + Mode, + NothingChanged, + format_cell, + format_file_contents, + format_file_in_place, + main, +) +from black.handle_ipynb_magics import ( + Replacement, + create_token, + jupyter_dependencies_are_installed, + unmask_cell, +) +from tests.util import DATA_DIR, get_case_path, read_jupyter_notebook + +with contextlib.suppress(ModuleNotFoundError): + import IPython +pytestmark = pytest.mark.jupyter +pytest.importorskip("IPython", reason="IPython is an optional dependency") +pytest.importorskip("tokenize_rt", reason="tokenize-rt is an optional dependency") + +JUPYTER_MODE = Mode(is_ipynb=True) + +EMPTY_CONFIG = DATA_DIR / "empty_pyproject.toml" + +runner = CliRunner() + + +def test_noop() -> None: + src = 'foo = "a"' + with pytest.raises(NothingChanged): + format_cell(src, fast=True, mode=JUPYTER_MODE) + + +@pytest.mark.parametrize("n_chars", [1, 2, 3, 4, 5, 17]) +def test_create_token_uses_requested_length(n_chars: int) -> None: + assert len(create_token(n_chars)) == n_chars + + +def test_unmask_cell_raises_when_token_is_not_unique() -> None: + replacement = Replacement(mask='b"dead"', src="%time") + with pytest.raises(NothingChanged): + unmask_cell(f"{replacement.mask}\nvalue = {replacement.mask}", [replacement]) + + +@pytest.mark.parametrize("fast", [True, False]) +def test_trailing_semicolon(fast: bool) -> None: + src = 'foo = "a" ;' + result = format_cell(src, fast=fast, mode=JUPYTER_MODE) + expected = 'foo = "a";' + assert result == expected + + +def test_trailing_semicolon_with_comment() -> None: + src = 'foo = "a" ; # bar' + result = format_cell(src, fast=True, mode=JUPYTER_MODE) + expected = 'foo = "a"; # bar' + assert result == expected + + +def test_trailing_semicolon_with_comment_on_next_line() -> None: + src = "import black;\n\n# this is a comment" + with pytest.raises(NothingChanged): + format_cell(src, fast=True, mode=JUPYTER_MODE) + + +def test_trailing_semicolon_indented() -> None: + src = "with foo:\n plot_bar();" + with pytest.raises(NothingChanged): + format_cell(src, fast=True, mode=JUPYTER_MODE) + + +def test_trailing_semicolon_noop() -> None: + src = 'foo = "a";' + with pytest.raises(NothingChanged): + format_cell(src, fast=True, mode=JUPYTER_MODE) + + +@pytest.mark.parametrize( + "mode", + [ + pytest.param(JUPYTER_MODE, id="default mode"), + pytest.param( + replace(JUPYTER_MODE, python_cell_magics={"cust1", "cust2"}), + id="custom cell magics mode", + ), + ], +) +def test_cell_magic(mode: Mode) -> None: + src = "%%time\nfoo =bar" + result = format_cell(src, fast=True, mode=mode) + expected = "%%time\nfoo = bar" + assert result == expected + + +def test_cell_magic_noop() -> None: + src = "%%time\n2 + 2" + with pytest.raises(NothingChanged): + format_cell(src, fast=True, mode=JUPYTER_MODE) + + +@pytest.mark.parametrize( + "mode", + [ + pytest.param(JUPYTER_MODE, id="default mode"), + pytest.param( + replace(JUPYTER_MODE, python_cell_magics={"cust1", "cust2"}), + id="custom cell magics mode", + ), + ], +) +@pytest.mark.parametrize( + "src, expected", + ( + pytest.param("ls =!ls", "ls = !ls", id="System assignment"), + pytest.param("!ls\n'foo'", '!ls\n"foo"', id="System call"), + pytest.param("!!ls\n'foo'", '!!ls\n"foo"', id="Other system call"), + pytest.param("?str\n'foo'", '?str\n"foo"', id="Help"), + pytest.param("??str\n'foo'", '??str\n"foo"', id="Other help"), + pytest.param( + "%matplotlib inline\n'foo'", + '%matplotlib inline\n"foo"', + id="Line magic with argument", + ), + pytest.param("%time\n'foo'", '%time\n"foo"', id="Line magic without argument"), + pytest.param( + "env = %env var", "env = %env var", id="Assignment to environment variable" + ), + pytest.param("env = %env", "env = %env", id="Assignment to magic"), + ), +) +def test_magic(src: str, expected: str, mode: Mode) -> None: + result = format_cell(src, fast=True, mode=mode) + assert result == expected + + +@pytest.mark.parametrize( + "src", + ( + "%%bash\n2+2", + "%%html --isolated\n2+2", + "%%writefile e.txt\n meh\n meh", + ), +) +def test_non_python_magics(src: str) -> None: + with pytest.raises(NothingChanged): + format_cell(src, fast=True, mode=JUPYTER_MODE) + + +@pytest.mark.skipif( + IPython.version_info < (8, 3), + reason="Change in how TransformerManager transforms this input", +) +def test_set_input() -> None: + src = "a = b??" + expected = "??b" + result = format_cell(src, fast=True, mode=JUPYTER_MODE) + assert result == expected + + +def test_input_already_contains_transformed_magic() -> None: + src = '%time foo()\nget_ipython().run_cell_magic("time", "", "foo()\\n")' + with pytest.raises(NothingChanged): + format_cell(src, fast=True, mode=JUPYTER_MODE) + + +def test_magic_noop() -> None: + src = "ls = !ls" + with pytest.raises(NothingChanged): + format_cell(src, fast=True, mode=JUPYTER_MODE) + + +def test_cell_magic_with_magic() -> None: + src = "%%timeit -n1\nls =!ls" + result = format_cell(src, fast=True, mode=JUPYTER_MODE) + expected = "%%timeit -n1\nls = !ls" + assert result == expected + + +@pytest.mark.parametrize( + "src, expected", + ( + ("\n\n\n%time \n\n", "%time"), + (" \n\t\n%%timeit -n4 \t \nx=2 \n\r\n", "%%timeit -n4\nx = 2"), + ( + " \t\n\n%%capture \nx=2 \n%config \n\n%env\n\t \n \n\n", + "%%capture\nx = 2\n%config\n\n%env", + ), + ), +) +def test_cell_magic_with_empty_lines(src: str, expected: str) -> None: + result = format_cell(src, fast=True, mode=JUPYTER_MODE) + assert result == expected + + +@pytest.mark.parametrize( + "mode, expected_output, expectation", + [ + pytest.param( + JUPYTER_MODE, + "%%custom_python_magic -n1 -n2\nx=2", + pytest.raises(NothingChanged), + id="No change when cell magic not registered", + ), + pytest.param( + replace(JUPYTER_MODE, python_cell_magics={"cust1", "cust2"}), + "%%custom_python_magic -n1 -n2\nx=2", + pytest.raises(NothingChanged), + id="No change when other cell magics registered", + ), + pytest.param( + replace(JUPYTER_MODE, python_cell_magics={"custom_python_magic", "cust1"}), + "%%custom_python_magic -n1 -n2\nx = 2", + does_not_raise(), + id="Correctly change when cell magic registered", + ), + ], +) +def test_cell_magic_with_custom_python_magic( + mode: Mode, expected_output: str, expectation: AbstractContextManager[object] +) -> None: + with expectation: + result = format_cell( + "%%custom_python_magic -n1 -n2\nx=2", + fast=True, + mode=mode, + ) + assert result == expected_output + + +@pytest.mark.parametrize( + "src", + ( + " %%custom_magic \nx=2", + "\n\n%%custom_magic\nx=2", + "# comment\n%%custom_magic\nx=2", + "\n \n # comment with %%time\n\t\n %%custom_magic # comment \nx=2", + ), +) +def test_cell_magic_with_custom_python_magic_after_spaces_and_comments_noop( + src: str, +) -> None: + with pytest.raises(NothingChanged): + format_cell(src, fast=True, mode=JUPYTER_MODE) + + +def test_cell_magic_nested() -> None: + src = "%%time\n%%time\n2+2" + result = format_cell(src, fast=True, mode=JUPYTER_MODE) + expected = "%%time\n%%time\n2 + 2" + assert result == expected + + +def test_cell_magic_with_magic_noop() -> None: + src = "%%t -n1\nls = !ls" + with pytest.raises(NothingChanged): + format_cell(src, fast=True, mode=JUPYTER_MODE) + + +def test_automagic() -> None: + src = "pip install black" + with pytest.raises(NothingChanged): + format_cell(src, fast=True, mode=JUPYTER_MODE) + + +def test_multiline_magic() -> None: + src = "%time 1 + \\\n2" + with pytest.raises(NothingChanged): + format_cell(src, fast=True, mode=JUPYTER_MODE) + + +def test_multiline_no_magic() -> None: + src = "1 + \\\n2" + result = format_cell(src, fast=True, mode=JUPYTER_MODE) + expected = "1 + 2" + assert result == expected + + +def test_cell_magic_with_invalid_body() -> None: + src = "%%time\nif True" + with pytest.raises(NothingChanged): + format_cell(src, fast=True, mode=JUPYTER_MODE) + + +def test_empty_cell() -> None: + src = "" + with pytest.raises(NothingChanged): + format_cell(src, fast=True, mode=JUPYTER_MODE) + + +def test_entire_notebook_empty_metadata() -> None: + content = read_jupyter_notebook("jupyter", "notebook_empty_metadata") + result = format_file_contents(content, fast=True, mode=JUPYTER_MODE) + expected = ( + "{\n" + ' "cells": [\n' + " {\n" + ' "cell_type": "code",\n' + ' "execution_count": null,\n' + ' "metadata": {\n' + ' "tags": []\n' + " },\n" + ' "outputs": [],\n' + ' "source": [\n' + ' "%%time\\n",\n' + ' "\\n",\n' + ' "print(\\"foo\\")"\n' + " ]\n" + " },\n" + " {\n" + ' "cell_type": "code",\n' + ' "execution_count": null,\n' + ' "metadata": {},\n' + ' "outputs": [],\n' + ' "source": []\n' + " }\n" + " ],\n" + ' "metadata": {},\n' + ' "nbformat": 4,\n' + ' "nbformat_minor": 4\n' + "}\n" + ) + assert result == expected + + +def test_entire_notebook_trailing_newline() -> None: + content = read_jupyter_notebook("jupyter", "notebook_trailing_newline") + result = format_file_contents(content, fast=True, mode=JUPYTER_MODE) + expected = ( + "{\n" + ' "cells": [\n' + " {\n" + ' "cell_type": "code",\n' + ' "execution_count": null,\n' + ' "metadata": {\n' + ' "tags": []\n' + " },\n" + ' "outputs": [],\n' + ' "source": [\n' + ' "%%time\\n",\n' + ' "\\n",\n' + ' "print(\\"foo\\")"\n' + " ]\n" + " },\n" + " {\n" + ' "cell_type": "code",\n' + ' "execution_count": null,\n' + ' "metadata": {},\n' + ' "outputs": [],\n' + ' "source": []\n' + " }\n" + " ],\n" + ' "metadata": {\n' + ' "interpreter": {\n' + ' "hash": "e758f3098b5b55f4d87fe30bbdc1367f20f246b483f96267ee70e6c40cb185d8"\n' # noqa:B950 + " },\n" + ' "kernelspec": {\n' + ' "display_name": "Python 3.8.10 64-bit (\'black\': venv)",\n' + ' "name": "python3"\n' + " },\n" + ' "language_info": {\n' + ' "name": "python",\n' + ' "version": ""\n' + " }\n" + " },\n" + ' "nbformat": 4,\n' + ' "nbformat_minor": 4\n' + "}\n" + ) + assert result == expected + + +def test_entire_notebook_no_trailing_newline() -> None: + content = read_jupyter_notebook("jupyter", "notebook_no_trailing_newline") + result = format_file_contents(content, fast=True, mode=JUPYTER_MODE) + expected = ( + "{\n" + ' "cells": [\n' + " {\n" + ' "cell_type": "code",\n' + ' "execution_count": null,\n' + ' "metadata": {\n' + ' "tags": []\n' + " },\n" + ' "outputs": [],\n' + ' "source": [\n' + ' "%%time\\n",\n' + ' "\\n",\n' + ' "print(\\"foo\\")"\n' + " ]\n" + " },\n" + " {\n" + ' "cell_type": "code",\n' + ' "execution_count": null,\n' + ' "metadata": {},\n' + ' "outputs": [],\n' + ' "source": []\n' + " }\n" + " ],\n" + ' "metadata": {\n' + ' "interpreter": {\n' + ' "hash": "e758f3098b5b55f4d87fe30bbdc1367f20f246b483f96267ee70e6c40cb185d8"\n' # noqa: B950 + " },\n" + ' "kernelspec": {\n' + ' "display_name": "Python 3.8.10 64-bit (\'black\': venv)",\n' + ' "name": "python3"\n' + " },\n" + ' "language_info": {\n' + ' "name": "python",\n' + ' "version": ""\n' + " }\n" + " },\n" + ' "nbformat": 4,\n' + ' "nbformat_minor": 4\n' + "}" + ) + assert result == expected + + +def test_entire_notebook_without_changes() -> None: + content = read_jupyter_notebook("jupyter", "notebook_without_changes") + with pytest.raises(NothingChanged): + format_file_contents(content, fast=True, mode=JUPYTER_MODE) + + +def test_non_python_notebook() -> None: + content = read_jupyter_notebook("jupyter", "non_python_notebook") + + with pytest.raises(NothingChanged): + format_file_contents(content, fast=True, mode=JUPYTER_MODE) + + +def test_empty_string() -> None: + with pytest.raises(NothingChanged): + format_file_contents("", fast=True, mode=JUPYTER_MODE) + + +def test_unparseable_notebook() -> None: + path = get_case_path("jupyter", "notebook_which_cant_be_parsed.ipynb") + msg = rf"File '{re.escape(str(path))}' cannot be parsed as valid Jupyter notebook\." + with pytest.raises(ValueError, match=msg): + format_file_in_place(path, fast=True, mode=JUPYTER_MODE) + + +def test_ipynb_diff_with_change() -> None: + result = runner.invoke( + main, + [ + str(get_case_path("jupyter", "notebook_trailing_newline.ipynb")), + "--diff", + f"--config={EMPTY_CONFIG}", + ], + ) + expected = "@@ -1,3 +1,3 @@\n %%time\n \n-print('foo')\n+print(\"foo\")\n" + assert expected in result.output + + +def test_ipynb_diff_with_no_change() -> None: + result = runner.invoke( + main, + [ + str(get_case_path("jupyter", "notebook_without_changes.ipynb")), + "--diff", + f"--config={EMPTY_CONFIG}", + ], + ) + expected = "1 file would be left unchanged." + assert expected in result.output + + +def test_cache_isnt_written_if_no_jupyter_deps_single( + monkeypatch: MonkeyPatch, tmp_path: pathlib.Path +) -> None: + # Check that the cache isn't written to if Jupyter dependencies aren't installed. + jupyter_dependencies_are_installed.cache_clear() + nb = get_case_path("jupyter", "notebook_trailing_newline.ipynb") + tmp_nb = tmp_path / "notebook.ipynb" + tmp_nb.write_bytes(nb.read_bytes()) + monkeypatch.setattr("black.jupyter_dependencies_are_installed", lambda warn: False) + result = runner.invoke( + main, [str(tmp_path / "notebook.ipynb"), f"--config={EMPTY_CONFIG}"] + ) + assert "No Python files are present to be formatted. Nothing to do" in result.output + jupyter_dependencies_are_installed.cache_clear() + monkeypatch.setattr("black.jupyter_dependencies_are_installed", lambda warn: True) + result = runner.invoke( + main, [str(tmp_path / "notebook.ipynb"), f"--config={EMPTY_CONFIG}"] + ) + assert "reformatted" in result.output + + +def test_cache_isnt_written_if_no_jupyter_deps_dir( + monkeypatch: MonkeyPatch, tmp_path: pathlib.Path +) -> None: + # Check that the cache isn't written to if Jupyter dependencies aren't installed. + jupyter_dependencies_are_installed.cache_clear() + nb = get_case_path("jupyter", "notebook_trailing_newline.ipynb") + tmp_nb = tmp_path / "notebook.ipynb" + tmp_nb.write_bytes(nb.read_bytes()) + monkeypatch.setattr( + "black.files.jupyter_dependencies_are_installed", lambda warn: False + ) + result = runner.invoke(main, [str(tmp_path), f"--config={EMPTY_CONFIG}"]) + assert "No Python files are present to be formatted. Nothing to do" in result.output + jupyter_dependencies_are_installed.cache_clear() + monkeypatch.setattr( + "black.files.jupyter_dependencies_are_installed", lambda warn: True + ) + result = runner.invoke(main, [str(tmp_path), f"--config={EMPTY_CONFIG}"]) + assert "reformatted" in result.output + + +def test_ipynb_flag(tmp_path: pathlib.Path) -> None: + nb = get_case_path("jupyter", "notebook_trailing_newline.ipynb") + tmp_nb = tmp_path / "notebook.a_file_extension_which_is_definitely_not_ipynb" + tmp_nb.write_bytes(nb.read_bytes()) + result = runner.invoke( + main, + [ + str(tmp_nb), + "--diff", + "--ipynb", + f"--config={EMPTY_CONFIG}", + ], + ) + expected = "@@ -1,3 +1,3 @@\n %%time\n \n-print('foo')\n+print(\"foo\")\n" + assert expected in result.output + + +def test_ipynb_and_pyi_flags() -> None: + nb = get_case_path("jupyter", "notebook_trailing_newline.ipynb") + result = runner.invoke( + main, + [ + str(nb), + "--pyi", + "--ipynb", + "--diff", + f"--config={EMPTY_CONFIG}", + ], + ) + assert isinstance(result.exception, SystemExit) + expected = "Cannot pass both `pyi` and `ipynb` flags!\n" + assert result.output == expected + + +def test_unable_to_replace_magics(monkeypatch: MonkeyPatch) -> None: + src = '%%time\na = b"foo"' + monkeypatch.setattr("secrets.token_hex", lambda _: "foo") + with pytest.raises( + AssertionError, match="Black was not able to replace IPython magic" + ): + format_cell(src, fast=True, mode=JUPYTER_MODE) diff --git a/tests/test_no_ipynb.py b/tests/test_no_ipynb.py new file mode 100644 index 0000000..12c820d --- /dev/null +++ b/tests/test_no_ipynb.py @@ -0,0 +1,36 @@ +import pathlib + +import pytest +from click.testing import CliRunner + +from black import jupyter_dependencies_are_installed, main +from tests.util import get_case_path + +pytestmark = pytest.mark.no_jupyter + +runner = CliRunner() + + +def test_ipynb_diff_with_no_change_single() -> None: + jupyter_dependencies_are_installed.cache_clear() + path = get_case_path("jupyter", "notebook_trailing_newline.ipynb") + result = runner.invoke(main, [str(path)]) + expected_output = ( + "Skipping .ipynb files as Jupyter dependencies are not installed.\n" + 'You can fix this by running ``pip install "black[jupyter]"``\n' + ) + assert expected_output in result.output + + +def test_ipynb_diff_with_no_change_dir(tmp_path: pathlib.Path) -> None: + jupyter_dependencies_are_installed.cache_clear() + runner = CliRunner() + nb = get_case_path("jupyter", "notebook_trailing_newline.ipynb") + tmp_nb = tmp_path / "notebook.ipynb" + tmp_nb.write_bytes(nb.read_bytes()) + result = runner.invoke(main, [str(tmp_path)]) + expected_output = ( + "Skipping .ipynb files as Jupyter dependencies are not installed.\n" + 'You can fix this by running ``pip install "black[jupyter]"``\n' + ) + assert expected_output in result.output diff --git a/tests/test_ranges.py b/tests/test_ranges.py new file mode 100644 index 0000000..189461d --- /dev/null +++ b/tests/test_ranges.py @@ -0,0 +1,275 @@ +"""Test the black.ranges module.""" + +import pytest + +from black.ranges import adjusted_lines, parse_line_ranges, sanitized_lines + + +@pytest.mark.parametrize( + "lines_str, expected", + [ + (["1-5"], [(1, 5)]), + (["1-1"], [(1, 1)]), + (["1-3", "5-7"], [(1, 3), (5, 7)]), + ], +) +def test_parse_line_ranges_valid( + lines_str: list[str], expected: list[tuple[int, int]] +) -> None: + assert parse_line_ranges(lines_str) == expected + + +@pytest.mark.parametrize( + "lines_str", + [ + ["5-3"], + ["0-5"], + ["-1-5"], + ["5-0"], + ], +) +def test_parse_line_ranges_invalid(lines_str: list[str]) -> None: + with pytest.raises(ValueError, match="Incorrect --line-ranges"): + parse_line_ranges(lines_str) + + +@pytest.mark.parametrize( + "lines", + [[(1, 1)], [(1, 3)], [(1, 1), (3, 4)]], +) +def test_no_diff(lines: list[tuple[int, int]]) -> None: + source = """\ +import re + +def func(): +pass +""" + assert lines == adjusted_lines(lines, source, source) + + +@pytest.mark.parametrize( + "lines", + [ + [(1, 0)], + [(-8, 0)], + [(-8, 8)], + [(1, 100)], + [(2, 1)], + [(0, 8), (3, 1)], + ], +) +def test_invalid_lines(lines: list[tuple[int, int]]) -> None: + original_source = """\ +import re +def foo(arg): +'''This is the foo function. + +This is foo function's +docstring with more descriptive texts. +''' + +def func(arg1, +arg2, arg3): +pass +""" + modified_source = """\ +import re +def foo(arg): +'''This is the foo function. + +This is foo function's +docstring with more descriptive texts. +''' + +def func(arg1, arg2, arg3): +pass +""" + assert not adjusted_lines(lines, original_source, modified_source) + + +@pytest.mark.parametrize( + "lines,adjusted", + [ + ( + [(1, 1)], + [(1, 1)], + ), + ( + [(1, 2)], + [(1, 1)], + ), + ( + [(1, 6)], + [(1, 2)], + ), + ( + [(6, 6)], + [], + ), + ], +) +def test_removals( + lines: list[tuple[int, int]], adjusted: list[tuple[int, int]] +) -> None: + original_source = """\ +1. first line +2. second line +3. third line +4. fourth line +5. fifth line +6. sixth line +""" + modified_source = """\ +2. second line +5. fifth line +""" + assert adjusted == adjusted_lines(lines, original_source, modified_source) + + +@pytest.mark.parametrize( + "lines,adjusted", + [ + ( + [(1, 1)], + [(2, 2)], + ), + ( + [(1, 2)], + [(2, 5)], + ), + ( + [(2, 2)], + [(5, 5)], + ), + ], +) +def test_additions( + lines: list[tuple[int, int]], adjusted: list[tuple[int, int]] +) -> None: + original_source = """\ +1. first line +2. second line +""" + modified_source = """\ +this is added +1. first line +this is added +this is added +2. second line +this is added +""" + assert adjusted == adjusted_lines(lines, original_source, modified_source) + + +@pytest.mark.parametrize( + "lines,adjusted", + [ + ( + [(1, 11)], + [(1, 10)], + ), + ( + [(1, 12)], + [(1, 11)], + ), + ( + [(10, 10)], + [(9, 9)], + ), + ([(1, 1), (9, 10)], [(1, 1), (9, 9)]), + ([(9, 10), (1, 1)], [(1, 1), (9, 9)]), + ], +) +def test_diffs(lines: list[tuple[int, int]], adjusted: list[tuple[int, int]]) -> None: + original_source = """\ + 1. import re + 2. def foo(arg): + 3. '''This is the foo function. + 4. + 5. This is foo function's + 6. docstring with more descriptive texts. + 7. ''' + 8. + 9. def func(arg1, +10. arg2, arg3): +11. pass +12. # last line +""" + modified_source = """\ + 1. import re # changed + 2. def foo(arg): + 3. '''This is the foo function. + 4. + 5. This is foo function's + 6. docstring with more descriptive texts. + 7. ''' + 8. + 9. def func(arg1, arg2, arg3): +11. pass +12. # last line changed +""" + assert adjusted == adjusted_lines(lines, original_source, modified_source) + + +@pytest.mark.parametrize( + "lines,sanitized", + [ + ( + [(1, 4)], + [(1, 4)], + ), + ( + [(2, 3)], + [(2, 3)], + ), + ( + [(2, 10)], + [(2, 4)], + ), + ( + [(0, 3)], + [(1, 3)], + ), + ( + [(0, 10)], + [(1, 4)], + ), + ( + [(-2, 3)], + [(1, 3)], + ), + ( + [(0, 0)], + [], + ), + ( + [(-2, -1)], + [], + ), + ( + [(-1, 0)], + [], + ), + ( + [(3, 1), (1, 3), (5, 6)], + [(1, 3)], + ), + ], +) +def test_sanitize( + lines: list[tuple[int, int]], sanitized: list[tuple[int, int]] +) -> None: + source = """\ +1. import re +2. def func(arg1, +3. arg2, arg3): +4. pass +""" + assert sanitized == sanitized_lines(lines, source) + + source_no_trailing_nl = """\ + 1. import re + 2. def func(arg1, + 3. arg2, arg3): + 4. pass""" + assert sanitized == sanitized_lines(lines, source_no_trailing_nl) diff --git a/tests/test_schema.py b/tests/test_schema.py new file mode 100644 index 0000000..1798b39 --- /dev/null +++ b/tests/test_schema.py @@ -0,0 +1,12 @@ +import importlib.metadata + + +def test_schema_entrypoint() -> None: + (black_ep,) = importlib.metadata.entry_points( + group="validate_pyproject.tool_schema", name="black" + ) + + black_fn = black_ep.load() + schema = black_fn() + assert schema == black_fn("black") + assert schema["properties"]["line-length"]["type"] == "integer" diff --git a/tests/test_tokenize.py b/tests/test_tokenize.py new file mode 100644 index 0000000..efa7ad5 --- /dev/null +++ b/tests/test_tokenize.py @@ -0,0 +1,107 @@ +"""Tests for the blib2to3 tokenizer.""" + +import sys +import textwrap +from dataclasses import dataclass + +import black +from blib2to3.pgen2 import token, tokenize + + +@dataclass +class Token: + type: str + string: str + start: tokenize.Coord + end: tokenize.Coord + + +def get_tokens(text: str) -> list[Token]: + """Return the tokens produced by the tokenizer.""" + return [ + Token(token.tok_name[tok_type], string, start, end) + for tok_type, string, start, end, _ in tokenize.tokenize(text) + ] + + +def assert_tokenizes(text: str, tokens: list[Token]) -> None: + """Assert that the tokenizer produces the expected tokens.""" + actual_tokens = get_tokens(text) + assert actual_tokens == tokens + + +def test_simple() -> None: + assert_tokenizes( + "1", + [Token("NUMBER", "1", (1, 0), (1, 1)), Token("ENDMARKER", "", (2, 0), (2, 0))], + ) + assert_tokenizes( + "'a'", + [ + Token("STRING", "'a'", (1, 0), (1, 3)), + Token("ENDMARKER", "", (2, 0), (2, 0)), + ], + ) + assert_tokenizes( + "a", + [Token("NAME", "a", (1, 0), (1, 1)), Token("ENDMARKER", "", (2, 0), (2, 0))], + ) + + +def test_fstring() -> None: + assert_tokenizes( + 'f"x"', + [ + Token("FSTRING_START", 'f"', (1, 0), (1, 2)), + Token("FSTRING_MIDDLE", "x", (1, 2), (1, 3)), + Token("FSTRING_END", '"', (1, 3), (1, 4)), + Token("ENDMARKER", "", (2, 0), (2, 0)), + ], + ) + assert_tokenizes( + 'f"{x}"', + [ + Token("FSTRING_START", 'f"', (1, 0), (1, 2)), + Token("OP", "{", (1, 2), (1, 3)), + Token("NAME", "x", (1, 3), (1, 4)), + Token("OP", "}", (1, 4), (1, 5)), + Token("FSTRING_END", '"', (1, 5), (1, 6)), + Token("ENDMARKER", "", (2, 0), (2, 0)), + ], + ) + assert_tokenizes( + 'f"{x:y}"\n', + [ + Token(type="FSTRING_START", string='f"', start=(1, 0), end=(1, 2)), + Token(type="OP", string="{", start=(1, 2), end=(1, 3)), + Token(type="NAME", string="x", start=(1, 3), end=(1, 4)), + Token(type="OP", string=":", start=(1, 4), end=(1, 5)), + Token(type="FSTRING_MIDDLE", string="y", start=(1, 5), end=(1, 6)), + Token(type="OP", string="}", start=(1, 6), end=(1, 7)), + Token(type="FSTRING_END", string='"', start=(1, 7), end=(1, 8)), + Token(type="NEWLINE", string="\n", start=(1, 8), end=(1, 9)), + Token(type="ENDMARKER", string="", start=(2, 0), end=(2, 0)), + ], + ) + assert_tokenizes( + 'f"x\\\n{a}"\n', + [ + Token(type="FSTRING_START", string='f"', start=(1, 0), end=(1, 2)), + Token(type="FSTRING_MIDDLE", string="x\\\n", start=(1, 2), end=(2, 0)), + Token(type="OP", string="{", start=(2, 0), end=(2, 1)), + Token(type="NAME", string="a", start=(2, 1), end=(2, 2)), + Token(type="OP", string="}", start=(2, 2), end=(2, 3)), + Token(type="FSTRING_END", string='"', start=(2, 3), end=(2, 4)), + Token(type="NEWLINE", string="\n", start=(2, 4), end=(2, 5)), + Token(type="ENDMARKER", string="", start=(3, 0), end=(3, 0)), + ], + ) + + +# Run "echo some code | python tests/test_tokenize.py" to generate test cases. +if __name__ == "__main__": + code = sys.stdin.read() + tokens = get_tokens(code) + text = f"assert_tokenizes({code!r}, {tokens!r})" + text = black.format_str(text, mode=black.Mode()) + print(textwrap.indent(text, " ")) diff --git a/tests/test_trans.py b/tests/test_trans.py new file mode 100644 index 0000000..d04eac7 --- /dev/null +++ b/tests/test_trans.py @@ -0,0 +1,49 @@ +from black.trans import iter_fexpr_spans + + +def test_fexpr_spans() -> None: + def check( + string: str, expected_spans: list[tuple[int, int]], expected_slices: list[str] + ) -> None: + spans = list(iter_fexpr_spans(string)) + + # Checking slices isn't strictly necessary, but it's easier to verify at + # a glance than only spans + assert len(spans) == len(expected_slices) + for (i, j), slice in zip(spans, expected_slices, strict=True): + assert 0 <= i <= j <= len(string) + assert string[i:j] == slice + + assert spans == expected_spans + + # Most of these test cases omit the leading 'f' and leading / closing quotes + # for convenience + # Some additional property-based tests can be found in + # https://github.com/psf/black/pull/2654#issuecomment-981411748 + check("""{var}""", [(0, 5)], ["{var}"]) + check("""f'{var}'""", [(2, 7)], ["{var}"]) + check("""f'{1 + f() + 2 + "asdf"}'""", [(2, 24)], ["""{1 + f() + 2 + "asdf"}"""]) + check("""text {var} text""", [(5, 10)], ["{var}"]) + check("""text {{ {var} }} text""", [(8, 13)], ["{var}"]) + check("""{a} {b} {c}""", [(0, 3), (4, 7), (8, 11)], ["{a}", "{b}", "{c}"]) + check("""f'{a} {b} {c}'""", [(2, 5), (6, 9), (10, 13)], ["{a}", "{b}", "{c}"]) + check("""{ {} }""", [(0, 6)], ["{ {} }"]) + check("""{ {{}} }""", [(0, 8)], ["{ {{}} }"]) + check("""{ {{{}}} }""", [(0, 10)], ["{ {{{}}} }"]) + check("""{{ {{{}}} }}""", [(5, 7)], ["{}"]) + check("""{{ {{{var}}} }}""", [(5, 10)], ["{var}"]) + check("""{f"{0}"}""", [(0, 8)], ["""{f"{0}"}"""]) + check("""{"'"}""", [(0, 5)], ["""{"'"}"""]) + check("""{"{"}""", [(0, 5)], ["""{"{"}"""]) + check("""{"}"}""", [(0, 5)], ["""{"}"}"""]) + check("""{"{{"}""", [(0, 6)], ["""{"{{"}"""]) + check("""{''' '''}""", [(0, 9)], ["""{''' '''}"""]) + check("""{'''{'''}""", [(0, 9)], ["""{'''{'''}"""]) + check("""{''' {'{ '''}""", [(0, 13)], ["""{''' {'{ '''}"""]) + check( + '''f\'\'\'-{f"""*{f"+{f'.{x}.'}+"}*"""}-'y\\'\'\'\'''', + [(5, 33)], + ['''{f"""*{f"+{f'.{x}.'}+"}*"""}'''], + ) + check(r"""{}{""", [(0, 2)], ["{}"]) + check("""f"{'{'''''''''}\"""", [(2, 15)], ["{'{'''''''''}"]) diff --git a/tests/util.py b/tests/util.py new file mode 100644 index 0000000..0acce4b --- /dev/null +++ b/tests/util.py @@ -0,0 +1,355 @@ +import argparse +import functools +import os +import shlex +import sys +import unittest +from collections.abc import Collection, Iterator +from contextlib import contextmanager +from dataclasses import dataclass, field, replace +from functools import partial +from pathlib import Path +from typing import Any + +import black +from black.const import DEFAULT_LINE_LENGTH +from black.debug import DebugVisitor +from black.mode import TargetVersion +from black.output import diff, err, out +from black.ranges import parse_line_ranges + +from . import conftest + +PYTHON_SUFFIX = ".py" +ALLOWED_SUFFIXES = (PYTHON_SUFFIX, ".pyi", ".out", ".diff", ".ipynb") + +THIS_DIR = Path(__file__).parent +DATA_DIR = THIS_DIR / "data" +PROJECT_ROOT = THIS_DIR.parent +EMPTY_LINE = "# EMPTY LINE WITH WHITESPACE" + " (this comment will be removed)" +DETERMINISTIC_HEADER = "[Deterministic header]" + +PY36_VERSIONS = { + TargetVersion.PY36, + TargetVersion.PY37, + TargetVersion.PY38, + TargetVersion.PY39, +} + +DEFAULT_MODE = black.Mode() +ff = partial(black.format_file_in_place, mode=DEFAULT_MODE, fast=True) +fs = partial(black.format_str, mode=DEFAULT_MODE) + + +@dataclass +class TestCaseArgs: + mode: black.Mode = field(default_factory=black.Mode) + fast: bool = False + minimum_version: tuple[int, int] | None = None + lines: Collection[tuple[int, int]] = () + no_preview_line_length_1: bool = False + + +def _assert_format_equal(expected: str, actual: str) -> None: + if actual != expected and (conftest.PRINT_FULL_TREE or conftest.PRINT_TREE_DIFF): + bdv: DebugVisitor[Any] + actual_out: str = "" + expected_out: str = "" + if conftest.PRINT_FULL_TREE: + out("Expected tree:", fg="green") + try: + exp_node = black.lib2to3_parse(expected) + bdv = DebugVisitor(print_output=conftest.PRINT_FULL_TREE) + list(bdv.visit(exp_node)) + expected_out = "\n".join(bdv.list_output) + except Exception as ve: + err(str(ve)) + if conftest.PRINT_FULL_TREE: + out("Actual tree:", fg="red") + try: + exp_node = black.lib2to3_parse(actual) + bdv = DebugVisitor(print_output=conftest.PRINT_FULL_TREE) + list(bdv.visit(exp_node)) + actual_out = "\n".join(bdv.list_output) + except Exception as ve: + err(str(ve)) + if conftest.PRINT_TREE_DIFF: + out("Tree Diff:") + out( + diff(expected_out, actual_out, "expected tree", "actual tree") + or "Trees do not differ" + ) + + if actual != expected: + out(diff(expected, actual, "expected", "actual")) + + assert actual == expected + + +class FormatFailure(Exception): + """Used to wrap failures when assert_format() runs in an extra mode.""" + + +def assert_format( + source: str, + expected: str, + mode: black.Mode = DEFAULT_MODE, + *, + fast: bool = False, + minimum_version: tuple[int, int] | None = None, + lines: Collection[tuple[int, int]] = (), + no_preview_line_length_1: bool = False, +) -> None: + """Convenience function to check that Black formats as expected. + + You can pass @minimum_version if you're passing code with newer syntax to guard + safety guards so they don't just crash with a SyntaxError. Please note this is + separate from TargetVerson Mode configuration. + """ + _assert_format_inner( + source, expected, mode, fast=fast, minimum_version=minimum_version, lines=lines + ) + + # For both preview and non-preview tests, ensure that Black doesn't crash on + # this code, but don't pass "expected" because the precise output may differ. + try: + if mode.unstable: + new_mode = replace(mode, unstable=False, preview=False) + else: + new_mode = replace(mode, preview=not mode.preview) + _assert_format_inner( + source, + None, + new_mode, + fast=fast, + minimum_version=minimum_version, + lines=lines, + ) + except Exception as e: + text = ( + "unstable" + if mode.unstable + else "non-preview" if mode.preview else "preview" + ) + raise FormatFailure( + f"Black crashed formatting this case in {text} mode." + ) from e + # Similarly, setting line length to 1 is a good way to catch + # stability bugs. Some tests are known to be broken in preview mode with line length + # of 1 though, and have marked that with a flag --no-preview-line-length-1 + preview_modes = [False] + if not no_preview_line_length_1: + preview_modes.append(True) + + for preview_mode in preview_modes: + + try: + _assert_format_inner( + source, + None, + replace(mode, preview=preview_mode, line_length=1, unstable=False), + fast=fast, + minimum_version=minimum_version, + lines=lines, + ) + except Exception as e: + text = "preview" if preview_mode else "non-preview" + raise FormatFailure( + f"Black crashed formatting this case in {text} mode with line-length=1." + ) from e + + +def _assert_format_inner( + source: str, + expected: str | None = None, + mode: black.Mode = DEFAULT_MODE, + *, + fast: bool = False, + minimum_version: tuple[int, int] | None = None, + lines: Collection[tuple[int, int]] = (), +) -> None: + actual = black.format_str(source, mode=mode, lines=lines) + if expected is not None: + _assert_format_equal(expected, actual) + # It's not useful to run safety checks if we're expecting no changes anyway. The + # assertion right above will raise if reality does actually make changes. This just + # avoids wasted CPU cycles. + if not fast and source != actual: + # Unfortunately the AST equivalence check relies on the built-in ast module + # being able to parse the code being formatted. This doesn't always work out + # when checking modern code on older versions. + if minimum_version is None or sys.version_info >= minimum_version: + black.assert_equivalent(source, actual) + black.assert_stable(source, actual, mode=mode, lines=lines) + + +def dump_to_stderr(*output: str) -> str: + return "\n" + "\n".join(output) + "\n" + + +class BlackBaseTestCase(unittest.TestCase): + def assertFormatEqual(self, expected: str, actual: str) -> None: + _assert_format_equal(expected, actual) + + +def get_base_dir(data: bool) -> Path: + return DATA_DIR if data else PROJECT_ROOT + + +def all_data_cases(subdir_name: str, data: bool = True) -> list[str]: + cases_dir = get_base_dir(data) / subdir_name + assert cases_dir.is_dir() + return [case_path.stem for case_path in cases_dir.iterdir()] + + +def get_case_path( + subdir_name: str, name: str, data: bool = True, suffix: str = PYTHON_SUFFIX +) -> Path: + """Get case path from name""" + case_path = get_base_dir(data) / subdir_name / name + if not name.endswith(ALLOWED_SUFFIXES): + case_path = case_path.with_suffix(suffix) + assert case_path.is_file(), f"{case_path} is not a file." + return case_path + + +def read_data_with_mode( + subdir_name: str, name: str, data: bool = True +) -> tuple[TestCaseArgs, str, str]: + """read_data_with_mode('test_name') -> Mode(), 'input', 'output'""" + return read_data_from_file(get_case_path(subdir_name, name, data)) + + +def read_data(subdir_name: str, name: str, data: bool = True) -> tuple[str, str]: + """read_data('test_name') -> 'input', 'output'""" + _, input, output = read_data_with_mode(subdir_name, name, data) + return input, output + + +def _parse_minimum_version(version: str) -> tuple[int, int]: + major, minor = version.split(".") + return int(major), int(minor) + + +@functools.lru_cache +def get_flags_parser() -> argparse.ArgumentParser: + parser = argparse.ArgumentParser() + parser.add_argument( + "--target-version", + action="store", + type=lambda val: (TargetVersion[val.upper()],), + default=(), + ) + parser.add_argument("--line-length", default=DEFAULT_LINE_LENGTH, type=int) + parser.add_argument( + "--skip-string-normalization", default=False, action="store_true" + ) + parser.add_argument("--pyi", default=False, action="store_true") + parser.add_argument("--ipynb", default=False, action="store_true") + parser.add_argument( + "--skip-magic-trailing-comma", default=False, action="store_true" + ) + parser.add_argument("--preview", default=False, action="store_true") + parser.add_argument("--unstable", default=False, action="store_true") + parser.add_argument("--fast", default=False, action="store_true") + parser.add_argument( + "--minimum-version", + type=_parse_minimum_version, + default=None, + help=( + "Minimum version of Python where this test case is parseable. If this is" + " set, the test case will be run twice: once without the specified" + " --target-version, and once with --target-version set to exactly the" + " specified version. This ensures that Black's autodetection of the target" + " version works correctly." + ), + ) + parser.add_argument("--line-ranges", action="append") + parser.add_argument( + "--no-preview-line-length-1", + default=False, + action="store_true", + help=( + "Don't run in preview mode with --line-length=1, as that's known to cause a" + " crash" + ), + ) + return parser + + +def parse_mode(flags_line: str) -> TestCaseArgs: + parser = get_flags_parser() + args = parser.parse_args(shlex.split(flags_line)) + mode = black.Mode( + target_versions=set(args.target_version), + line_length=args.line_length, + string_normalization=not args.skip_string_normalization, + is_pyi=args.pyi, + is_ipynb=args.ipynb, + magic_trailing_comma=not args.skip_magic_trailing_comma, + preview=args.preview, + unstable=args.unstable, + ) + if args.line_ranges: + lines = parse_line_ranges(args.line_ranges) + else: + lines = [] + return TestCaseArgs( + mode=mode, + fast=args.fast, + minimum_version=args.minimum_version, + lines=lines, + no_preview_line_length_1=args.no_preview_line_length_1, + ) + + +def read_data_from_file(file_name: Path) -> tuple[TestCaseArgs, str, str]: + with open(file_name, encoding="utf8") as test: + lines = test.readlines() + _input: list[str] = [] + _output: list[str] = [] + result = _input + mode = TestCaseArgs() + for line in lines: + if not _input and line.startswith("# flags: "): + mode = parse_mode(line[len("# flags: ") :]) + if mode.lines: + # Retain the `# flags: ` line when using --line-ranges=. This requires + # the `# output` section to also include this line, but retaining the + # line is important to make the line ranges match what you see in the + # test file. + result.append(line) + continue + line = line.replace(EMPTY_LINE, "") + if line.rstrip() == "# output": + result = _output + continue + + result.append(line) + if _input and not _output: + # If there's no output marker, treat the entire file as already pre-formatted. + _output = _input[:] + return mode, "".join(_input).strip() + "\n", "".join(_output).strip() + "\n" + + +def read_jupyter_notebook(subdir_name: str, name: str, data: bool = True) -> str: + return read_jupyter_notebook_from_file( + get_case_path(subdir_name, name, data, suffix=".ipynb") + ) + + +def read_jupyter_notebook_from_file(file_name: Path) -> str: + with open(file_name, mode="rb") as fd: + content_bytes = fd.read() + return content_bytes.decode() + + +@contextmanager +def change_directory(path: Path) -> Iterator[None]: + """Context manager to temporarily chdir to a different directory.""" + previous_dir = os.getcwd() + try: + os.chdir(path) + yield + finally: + os.chdir(previous_dir) diff --git a/tox.ini b/tox.ini new file mode 100644 index 0000000..0495e8e --- /dev/null +++ b/tox.ini @@ -0,0 +1,66 @@ +[tox] +isolated_build = true +envlist = {,ci-}py{310,311,312,313,314,315,py3},fuzz,run_self,generate_schema + +[testenv] +setenv = + PYTHONPATH = {toxinidir}/src + PYTHONWARNDEFAULTENCODING = 1 +skip_install = True +# We use `recreate=True` because otherwise, on the second run of `tox -e py`, +# the `no_jupyter` tests would run with the jupyter extra dependencies installed. +# See https://github.com/psf/black/issues/2367. +recreate = True +dependency_groups = cov-tests +commands = + pip install -e .[d] + coverage erase + pytest tests --run-optional no_jupyter \ + --numprocesses auto \ + --cov {posargs} + pip install -e .[jupyter] + pytest tests --run-optional jupyter \ + -m jupyter \ + --numprocesses auto \ + --cov --cov-append {posargs} + coverage report + +[testenv:{,ci-}pypy3] +setenv = + PYTHONPATH = {toxinidir}/src +skip_install = True +recreate = True +dependency_groups = tests +commands = + pip install -e .[d] + pytest tests --run-optional no_jupyter \ + --numprocesses auto + pip install -e .[jupyter] + pytest tests --run-optional jupyter \ + -m jupyter \ + --numprocesses auto + +[testenv:fuzz] +skip_install = True +dependency_groups = fuzz +commands = + pip install -e .[d] + coverage erase + coverage run {toxinidir}/scripts/fuzz.py + coverage report + +[testenv:run_self] +setenv = + PYTHONPATH = {toxinidir}/src +skip_install = True +commands = + pip install -e . + black --check {toxinidir} + +[testenv:generate_schema] +setenv = + PYTHONWARNDEFAULTENCODING = +skip_install = True +commands = + pip install -e . + python {toxinidir}/scripts/generate_schema.py --outfile {toxinidir}/src/black/resources/black.schema.json